]> git.lizzy.rs Git - dragonfireclient.git/blobdiff - src/mapblock.cpp
projects / dragonfireclient.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Turn off verbose info message introduced accidentally with ae9b1aa
[dragonfireclient.git] / src / mapblock.cpp
diff --git a/src/mapblock.cpp b/src/mapblock.cpp
index 2f6a4b850116522e8bd98c855f91819425ae8ec4..88f04e0bb56a0b14f14edf43839a694786279a5a 100644 (file)
--- a/src/mapblock.cpp
+++ b/src/mapblock.cpp
@@ -1,214 +1,141 @@
 /*
 /*
-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
 
 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
 (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.
 */
 
 #include "mapblock.h"
 with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
 #include "mapblock.h"
+
+#include <sstream>
 #include "map.h"
 #include "map.h"
-// For g_settings
-#include "main.h"
 #include "light.h"
 #include "light.h"
-#include <sstream>
+#include "nodedef.h"
+#include "nodemetadata.h"
+#include "gamedef.h"
+#include "log.h"
+#include "nameidmapping.h"
+#include "content_mapnode.h" // For legacy name-id mapping
+#include "content_nodemeta.h" // For legacy deserialization
+#include "serialization.h"
+#ifndef SERVER
+#include "mapblock_mesh.h"
+#endif
+#include "util/string.h"
+#include "util/serialize.h"
+#include "util/basic_macros.h"
+
+static const char *modified_reason_strings[] = {
+       "initial",
+       "reallocate",
+       "setIsUnderground",
+       "setLightingExpired",
+       "setGenerated",
+       "setNode",
+       "setNodeNoCheck",
+       "setTimestamp",
+       "NodeMetaRef::reportMetadataChange",
+       "clearAllObjects",
+       "Timestamp expired (step)",
+       "addActiveObjectRaw",
+       "removeRemovedObjects/remove",
+       "removeRemovedObjects/deactivate",
+       "Stored list cleared in activateObjects due to overflow",
+       "deactivateFarObjects: Static data moved in",
+       "deactivateFarObjects: Static data moved out",
+       "deactivateFarObjects: Static data changed considerably",
+       "finishBlockMake: expireDayNightDiff",
+       "unknown",
+};
+
 
 /*
        MapBlock
 */
 
 
 /*
        MapBlock
 */
 
-MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy):
+MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
                m_parent(parent),
                m_pos(pos),
                m_parent(parent),
                m_pos(pos),
-               m_modified(MOD_STATE_WRITE_NEEDED),
-               is_underground(false),
-               m_lighting_expired(true),
-               m_day_night_differs(false),
-               m_generated(false),
-               m_objects(this),
-               m_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
-               m_usage_timer(BLOCK_TIMESTAMP_UNDEFINED)
+               m_pos_relative(pos * MAP_BLOCKSIZE),
+               m_gamedef(gamedef)
 {
 {
-       data = NULL;
-       if(dummy == false)
+       if (!dummy)
                reallocate();
                reallocate();
-       
-       //m_spawn_timer = -10000;
-
-#ifndef SERVER
-       m_mesh_expired = false;
-       mesh_mutex.Init();
-       mesh = NULL;
-       m_temp_mods_mutex.Init();
-#endif
 }
 
 MapBlock::~MapBlock()
 {
 #ifndef SERVER
        {
 }
 
 MapBlock::~MapBlock()
 {
 #ifndef SERVER
        {
-               JMutexAutoLock lock(mesh_mutex);
-               
-               if(mesh)
-               {
-                       mesh->drop();
-                       mesh = NULL;
-               }
+               delete mesh;
+               mesh = nullptr;
        }
 #endif
 
        }
 #endif
 
-       if(data)
-               delete[] data;
+       delete[] data;
 }
 
 bool MapBlock::isValidPositionParent(v3s16 p)
 {
 }
 
 bool MapBlock::isValidPositionParent(v3s16 p)
 {
-       if(isValidPosition(p))
-       {
+       if (isValidPosition(p)) {
                return true;
        }
                return true;
        }
-       else{
-               return m_parent->isValidPosition(getPosRelative() + p);
-       }
-}
 
 
-MapNode MapBlock::getNodeParent(v3s16 p)
-{
-       if(isValidPosition(p) == false)
-       {
-               return m_parent->getNode(getPosRelative() + p);
-       }
-       else
-       {
-               if(data == NULL)
-                       throw InvalidPositionException();
-               return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
-       }
+       return m_parent->isValidPosition(getPosRelative() + p);
 }
 
 }
 
-void MapBlock::setNodeParent(v3s16 p, MapNode & n)
+MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position)
 {
 {
-       if(isValidPosition(p) == false)
-       {
-               m_parent->setNode(getPosRelative() + p, n);
-       }
-       else
-       {
-               if(data == NULL)
-                       throw InvalidPositionException();
-               data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n;
-       }
-}
+       if (!isValidPosition(p))
+               return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position);
 
 
-MapNode MapBlock::getNodeParentNoEx(v3s16 p)
-{
-       if(isValidPosition(p) == false)
-       {
-               try{
-                       return m_parent->getNode(getPosRelative() + p);
-               }
-               catch(InvalidPositionException &e)
-               {
-                       return MapNode(CONTENT_IGNORE);
-               }
-       }
-       else
-       {
-               if(data == NULL)
-               {
-                       return MapNode(CONTENT_IGNORE);
-               }
-               return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
-       }
-}
-
-#ifndef SERVER
-
-#if 1
-void MapBlock::updateMesh(u32 daynight_ratio)
-{
-#if 0
-       /*
-               DEBUG: If mesh has been generated, don't generate it again
-       */
-       {
-               JMutexAutoLock meshlock(mesh_mutex);
-               if(mesh != NULL)
-                       return;
+       if (!data) {
+               if (is_valid_position)
+                       *is_valid_position = false;
+               return {CONTENT_IGNORE};
        }
        }
-#endif
-
-       MeshMakeData data;
-       data.fill(daynight_ratio, this);
-       
-       scene::SMesh *mesh_new = makeMapBlockMesh(&data);
-       
-       /*
-               Replace the mesh
-       */
-
-       replaceMesh(mesh_new);
-
+       if (is_valid_position)
+               *is_valid_position = true;
+       return data[p.Z * zstride + p.Y * ystride + p.X];
 }
 }
-#endif
 
 
-void MapBlock::replaceMesh(scene::SMesh *mesh_new)
+std::string MapBlock::getModifiedReasonString()
 {
 {
-       mesh_mutex.Lock();
-
-       //scene::SMesh *mesh_old = mesh[daynight_i];
-       //mesh[daynight_i] = mesh_new;
+       std::string reason;
 
 
-       scene::SMesh *mesh_old = mesh;
-       mesh = mesh_new;
-       setMeshExpired(false);
-       
-       if(mesh_old != NULL)
-       {
-               // Remove hardware buffers of meshbuffers of mesh
-               // NOTE: No way, this runs in a different thread and everything
-               /*u32 c = mesh_old->getMeshBufferCount();
-               for(u32 i=0; i<c; i++)
-               {
-                       IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
-               }*/
-               
-               /*dstream<<"mesh_old->getReferenceCount()="
-                               <<mesh_old->getReferenceCount()<<std::endl;
-               u32 c = mesh_old->getMeshBufferCount();
-               for(u32 i=0; i<c; i++)
-               {
-                       scene::IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
-                       dstream<<"buf->getReferenceCount()="
-                                       <<buf->getReferenceCount()<<std::endl;
-               }*/
+       const u32 ubound = MYMIN(sizeof(m_modified_reason) * CHAR_BIT,
+               ARRLEN(modified_reason_strings));
 
 
-               // Drop the mesh
-               mesh_old->drop();
+       for (u32 i = 0; i != ubound; i++) {
+               if ((m_modified_reason & (1 << i)) == 0)
+                       continue;
 
 
-               //delete mesh_old;
+               reason += modified_reason_strings[i];
+               reason += ", ";
        }
 
        }
 
-       mesh_mutex.Unlock();
+       if (reason.length() > 2)
+               reason.resize(reason.length() - 2);
+
+       return reason;
 }
 }
-       
-#endif // !SERVER
 
 /*
        Propagates sunlight down through the block.
        Doesn't modify nodes that are not affected by sunlight.
 
 /*
        Propagates sunlight down through the block.
        Doesn't modify nodes that are not affected by sunlight.
-       
+
        Returns false if sunlight at bottom block is invalid.
        Returns true if sunlight at bottom block is valid.
        Returns true if bottom block doesn't exist.
        Returns false if sunlight at bottom block is invalid.
        Returns true if sunlight at bottom block is valid.
        Returns true if bottom block doesn't exist.
@@ -224,33 +151,45 @@ void MapBlock::replaceMesh(scene::SMesh *mesh_new)
        if black_air_left!=NULL, it is set to true if non-sunlighted
        air is left in block.
 */
        if black_air_left!=NULL, it is set to true if non-sunlighted
        air is left in block.
 */
-bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
+bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
                bool remove_light, bool *black_air_left)
 {
                bool remove_light, bool *black_air_left)
 {
+       INodeDefManager *nodemgr = m_gamedef->ndef();
+
        // Whether the sunlight at the top of the bottom block is valid
        bool block_below_is_valid = true;
        // Whether the sunlight at the top of the bottom block is valid
        bool block_below_is_valid = true;
-       
+
        v3s16 pos_relative = getPosRelative();
        v3s16 pos_relative = getPosRelative();
-       
+
        for(s16 x=0; x<MAP_BLOCKSIZE; x++)
        {
                for(s16 z=0; z<MAP_BLOCKSIZE; z++)
                {
 #if 1
                        bool no_sunlight = false;
        for(s16 x=0; x<MAP_BLOCKSIZE; x++)
        {
                for(s16 z=0; z<MAP_BLOCKSIZE; z++)
                {
 #if 1
                        bool no_sunlight = false;
-                       bool no_top_block = false;
+                       //bool no_top_block = false;
+
                        // Check if node above block has sunlight
                        // Check if node above block has sunlight
-                       try{
-                               MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
-                               if(n.d == CONTENT_IGNORE || n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
+
+                       bool is_valid_position;
+                       MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z),
+                               &is_valid_position);
+                       if (is_valid_position)
+                       {
+                               if(n.getContent() == CONTENT_IGNORE)
+                               {
+                                       // Trust heuristics
+                                       no_sunlight = is_underground;
+                               }
+                               else if(n.getLight(LIGHTBANK_DAY, m_gamedef->ndef()) != LIGHT_SUN)
                                {
                                        no_sunlight = true;
                                }
                        }
                                {
                                        no_sunlight = true;
                                }
                        }
-                       catch(InvalidPositionException &e)
+                       else
                        {
                        {
-                               no_top_block = true;
-                               
+                               //no_top_block = true;
+
                                // NOTE: This makes over-ground roofed places sunlighted
                                // Assume sunlight, unless is_underground==true
                                if(is_underground)
                                // NOTE: This makes over-ground roofed places sunlighted
                                // Assume sunlight, unless is_underground==true
                                if(is_underground)
@@ -259,10 +198,8 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                }
                                else
                                {
                                }
                                else
                                {
-                                       MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
-                                       //if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
-                                       if(content_features(n.d).sunlight_propagates == false)
-                                       {
+                                       MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z));
+                                       if (!m_gamedef->ndef()->get(n).sunlight_propagates) {
                                                no_sunlight = true;
                                        }
                                }
                                                no_sunlight = true;
                                        }
                                }
@@ -293,52 +230,30 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                        <<", is_underground="<<is_underground
                                        <<", no_sunlight="<<no_sunlight
                                        <<std::endl;*/
                                        <<", is_underground="<<is_underground
                                        <<", no_sunlight="<<no_sunlight
                                        <<std::endl;*/
-               
+
                        s16 y = MAP_BLOCKSIZE-1;
                        s16 y = MAP_BLOCKSIZE-1;
-                       
+
                        // This makes difference to diminishing in water.
                        bool stopped_to_solid_object = false;
                        // This makes difference to diminishing in water.
                        bool stopped_to_solid_object = false;
-                       
+
                        u8 current_light = no_sunlight ? 0 : LIGHT_SUN;
 
                        for(; y >= 0; y--)
                        {
                                v3s16 pos(x, y, z);
                                MapNode &n = getNodeRef(pos);
                        u8 current_light = no_sunlight ? 0 : LIGHT_SUN;
 
                        for(; y >= 0; y--)
                        {
                                v3s16 pos(x, y, z);
                                MapNode &n = getNodeRef(pos);
-                               
+
                                if(current_light == 0)
                                {
                                        // Do nothing
                                }
                                if(current_light == 0)
                                {
                                        // Do nothing
                                }
-                               else if(current_light == LIGHT_SUN && n.sunlight_propagates())
+                               else if(current_light == LIGHT_SUN && nodemgr->get(n).sunlight_propagates)
                                {
                                        // Do nothing: Sunlight is continued
                                {
                                        // Do nothing: Sunlight is continued
-                               }
-                               else if(n.light_propagates() == false)
-                               {
-                                       /*// DEPRECATED TODO: REMOVE
-                                       if(grow_grass)
-                                       {
-                                               bool upper_is_air = false;
-                                               try
-                                               {
-                                                       if(getNodeParent(pos+v3s16(0,1,0)).d == CONTENT_AIR)
-                                                               upper_is_air = true;
-                                               }
-                                               catch(InvalidPositionException &e)
-                                               {
-                                               }
-                                               // Turn mud into grass
-                                               if(upper_is_air && n.d == CONTENT_MUD
-                                                               && current_light == LIGHT_SUN)
-                                               {
-                                                       n.d = CONTENT_GRASS;
-                                               }
-                                       }*/
-
+                               } else if (!nodemgr->get(n).light_propagates) {
                                        // A solid object is on the way.
                                        stopped_to_solid_object = true;
                                        // A solid object is on the way.
                                        stopped_to_solid_object = true;
-                                       
+
                                        // Light stops.
                                        current_light = 0;
                                }
                                        // Light stops.
                                        current_light = 0;
                                }
@@ -348,16 +263,16 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                        current_light = diminish_light(current_light);
                                }
 
                                        current_light = diminish_light(current_light);
                                }
 
-                               u8 old_light = n.getLight(LIGHTBANK_DAY);
+                               u8 old_light = n.getLight(LIGHTBANK_DAY, nodemgr);
 
                                if(current_light > old_light || remove_light)
                                {
 
                                if(current_light > old_light || remove_light)
                                {
-                                       n.setLight(LIGHTBANK_DAY, current_light);
+                                       n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
                                }
                                }
-                               
+
                                if(diminish_light(current_light) != 0)
                                {
                                if(diminish_light(current_light) != 0)
                                {
-                                       light_sources.insert(pos_relative + pos, true);
+                                       light_sources.insert(pos_relative + pos);
                                }
 
                                if(current_light == 0 && stopped_to_solid_object)
                                }
 
                                if(current_light == 0 && stopped_to_solid_object)
@@ -377,30 +292,30 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
 
                                Check if the node below the block has proper sunlight at top.
                                If not, the block below is invalid.
 
                                Check if the node below the block has proper sunlight at top.
                                If not, the block below is invalid.
-                               
+
                                Ignore non-transparent nodes as they always have no light
                        */
                                Ignore non-transparent nodes as they always have no light
                        */
-                       try
-                       {
+
                        if(block_below_is_valid)
                        {
                        if(block_below_is_valid)
                        {
-                               MapNode n = getNodeParent(v3s16(x, -1, z));
-                               if(n.light_propagates())
+                               MapNode n = getNodeParent(v3s16(x, -1, z), &is_valid_position);
+                               if (is_valid_position) {
+                                       if(nodemgr->get(n).light_propagates)
+                                       {
+                                               if(n.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN
+                                                               && !sunlight_should_go_down)
+                                                       block_below_is_valid = false;
+                                               else if(n.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN
+                                                               && sunlight_should_go_down)
+                                                       block_below_is_valid = false;
+                                       }
+                               }
+                               else
                                {
                                {
-                                       if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN
-                                                       && sunlight_should_go_down == false)
-                                               block_below_is_valid = false;
-                                       else if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN
-                                                       && sunlight_should_go_down == true)
-                                               block_below_is_valid = false;
+                                       /*std::cout<<"InvalidBlockException for bottom block node"
+                                                       <<std::endl;*/
+                                       // Just no block below, no need to panic.
                                }
                                }
-                       }//if
-                       }//try
-                       catch(InvalidPositionException &e)
-                       {
-                               /*std::cout<<"InvalidBlockException for bottom block node"
-                                               <<std::endl;*/
-                               // Just no block below, no need to panic.
                        }
                }
        }
                        }
                }
        }
@@ -413,7 +328,7 @@ void MapBlock::copyTo(VoxelManipulator &dst)
 {
        v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
        VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
 {
        v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
        VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
-       
+
        // Copy from data to VoxelManipulator
        dst.copyFrom(data, data_area, v3s16(0,0,0),
                        getPosRelative(), data_size);
        // Copy from data to VoxelManipulator
        dst.copyFrom(data, data_area, v3s16(0,0,0),
                        getPosRelative(), data_size);
@@ -423,27 +338,20 @@ void MapBlock::copyFrom(VoxelManipulator &dst)
 {
        v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
        VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
 {
        v3s16 data_size(MAP_BLOCKSIZE, MAP_BLOCKSIZE, MAP_BLOCKSIZE);
        VoxelArea data_area(v3s16(0,0,0), data_size - v3s16(1,1,1));
-       
+
        // Copy from VoxelManipulator to data
        dst.copyTo(data, data_area, v3s16(0,0,0),
                        getPosRelative(), data_size);
 }
 
        // Copy from VoxelManipulator to data
        dst.copyTo(data, data_area, v3s16(0,0,0),
                        getPosRelative(), data_size);
 }
 
-void MapBlock::stepObjects(float dtime, bool server, u32 daynight_ratio)
+void MapBlock::actuallyUpdateDayNightDiff()
 {
 {
-       /*
-               Step objects
-       */
-       m_objects.step(dtime, server, daynight_ratio);
-
-       setChangedFlag();
-}
+       INodeDefManager *nodemgr = m_gamedef->ndef();
 
 
+       // Running this function un-expires m_day_night_differs
+       m_day_night_differs_expired = false;
 
 
-void MapBlock::updateDayNightDiff()
-{
-       if(data == NULL)
-       {
+       if (!data) {
                m_day_night_differs = false;
                return;
        }
                m_day_night_differs = false;
                return;
        }
@@ -453,33 +361,35 @@ void MapBlock::updateDayNightDiff()
        /*
                Check if any lighting value differs
        */
        /*
                Check if any lighting value differs
        */
-       for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-       {
-               MapNode &n = data[i];
-               if(n.getLight(LIGHTBANK_DAY) != n.getLight(LIGHTBANK_NIGHT))
-               {
-                       differs = true;
+
+       MapNode previous_n(CONTENT_IGNORE);
+       for (u32 i = 0; i < nodecount; i++) {
+               MapNode n = data[i];
+
+               // If node is identical to previous node, don't verify if it differs
+               if (n == previous_n)
+                       continue;
+
+               differs = !n.isLightDayNightEq(nodemgr);
+               if (differs)
                        break;
                        break;
-               }
+               previous_n = n;
        }
 
        /*
                If some lighting values differ, check if the whole thing is
        }
 
        /*
                If some lighting values differ, check if the whole thing is
-               just air. If it is, differ = false
+               just air. If it is just air, differs = false
        */
        */
-       if(differs)
-       {
+       if (differs) {
                bool only_air = true;
                bool only_air = true;
-               for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-               {
+               for (u32 i = 0; i < nodecount; i++) {
                        MapNode &n = data[i];
                        MapNode &n = data[i];
-                       if(n.d != CONTENT_AIR)
-                       {
+                       if (n.getContent() != CONTENT_AIR) {
                                only_air = false;
                                break;
                        }
                }
                                only_air = false;
                                break;
                        }
                }
-               if(only_air)
+               if (only_air)
                        differs = false;
        }
 
                        differs = false;
        }
 
@@ -487,6 +397,17 @@ void MapBlock::updateDayNightDiff()
        m_day_night_differs = differs;
 }
 
        m_day_night_differs = differs;
 }
 
+void MapBlock::expireDayNightDiff()
+{
+       if (!data) {
+               m_day_night_differs = false;
+               m_day_night_differs_expired = false;
+               return;
+       }
+
+       m_day_night_differs_expired = true;
+}
+
 s16 MapBlock::getGroundLevel(v2s16 p2d)
 {
        if(isDummy())
 s16 MapBlock::getGroundLevel(v2s16 p2d)
 {
        if(isDummy())
@@ -496,13 +417,12 @@ s16 MapBlock::getGroundLevel(v2s16 p2d)
                s16 y = MAP_BLOCKSIZE-1;
                for(; y>=0; y--)
                {
                s16 y = MAP_BLOCKSIZE-1;
                for(; y>=0; y--)
                {
-                       //if(is_ground_content(getNodeRef(p2d.X, y, p2d.Y).d))
-                       if(content_features(getNodeRef(p2d.X, y, p2d.Y).d).walkable)
-                       {
+                       MapNode n = getNodeRef(p2d.X, y, p2d.Y);
+                       if (m_gamedef->ndef()->get(n).walkable) {
                                if(y == MAP_BLOCKSIZE-1)
                                        return -2;
                                if(y == MAP_BLOCKSIZE-1)
                                        return -2;
-                               else
-                                       return y;
+
+                               return y;
                        }
                }
                return -1;
                        }
                }
                return -1;
@@ -516,197 +436,365 @@ s16 MapBlock::getGroundLevel(v2s16 p2d)
 /*
        Serialization
 */
 /*
        Serialization
 */
-
-void MapBlock::serialize(std::ostream &os, u8 version)
+// List relevant id-name pairs for ids in the block using nodedef
+// Renumbers the content IDs (starting at 0 and incrementing
+// use static memory requires about 65535 * sizeof(int) ram in order to be
+// sure we can handle all content ids. But it's absolutely worth it as it's
+// a speedup of 4 for one of the major time consuming functions on storing
+// mapblocks.
+static content_t getBlockNodeIdMapping_mapping[USHRT_MAX + 1];
+static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
+               INodeDefManager *nodedef)
 {
 {
-       if(!ser_ver_supported(version))
-               throw VersionMismatchException("ERROR: MapBlock format not supported");
-       
-       if(data == NULL)
-       {
-               throw SerializationError("ERROR: Not writing dummy block.");
-       }
-       
-       // These have no compression
-       if(version <= 3 || version == 5 || version == 6)
-       {
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-               
-               u32 buflen = 1 + nodecount * MapNode::serializedLength(version);
-               SharedBuffer<u8> dest(buflen);
+       memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t));
 
 
-               dest[0] = is_underground;
-               for(u32 i=0; i<nodecount; i++)
+       std::set<content_t> unknown_contents;
+       content_t id_counter = 0;
+       for (u32 i = 0; i < MapBlock::nodecount; i++) {
+               content_t global_id = nodes[i].getContent();
+               content_t id = CONTENT_IGNORE;
+
+               // Try to find an existing mapping
+               if (getBlockNodeIdMapping_mapping[global_id] != 0xFFFF) {
+                       id = getBlockNodeIdMapping_mapping[global_id];
+               }
+               else
                {
                {
-                       u32 s = 1 + i * MapNode::serializedLength(version);
-                       data[i].serialize(&dest[s], version);
+                       // We have to assign a new mapping
+                       id = id_counter++;
+                       getBlockNodeIdMapping_mapping[global_id] = id;
+
+                       const ContentFeatures &f = nodedef->get(global_id);
+                       const std::string &name = f.name;
+                       if (name.empty())
+                               unknown_contents.insert(global_id);
+                       else
+                               nimap->set(id, name);
                }
                }
-               
-               os.write((char*)*dest, dest.getSize());
-       }
-       else if(version <= 10)
-       {
-               /*
-                       With compression.
-                       Compress the materials and the params separately.
-               */
-               
-               // First byte
-               os.write((char*)&is_underground, 1);
-
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
 
 
-               // Get and compress materials
-               SharedBuffer<u8> materialdata(nodecount);
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       materialdata[i] = data[i].d;
+               // Update the MapNode
+               nodes[i].setContent(id);
+       }
+       for (u16 unknown_content : unknown_contents) {
+               errorstream << "getBlockNodeIdMapping(): IGNORING ERROR: "
+                               << "Name for node id " << unknown_content << " not known" << std::endl;
+       }
+}
+// Correct ids in the block to match nodedef based on names.
+// Unknown ones are added to nodedef.
+// Will not update itself to match id-name pairs in nodedef.
+static void correctBlockNodeIds(const NameIdMapping *nimap, MapNode *nodes,
+               IGameDef *gamedef)
+{
+       INodeDefManager *nodedef = gamedef->ndef();
+       // This means the block contains incorrect ids, and we contain
+       // the information to convert those to names.
+       // nodedef contains information to convert our names to globally
+       // correct ids.
+       std::unordered_set<content_t> unnamed_contents;
+       std::unordered_set<std::string> unallocatable_contents;
+
+       bool previous_exists = false;
+       content_t previous_local_id = CONTENT_IGNORE;
+       content_t previous_global_id = CONTENT_IGNORE;
+
+       for (u32 i = 0; i < MapBlock::nodecount; i++) {
+               content_t local_id = nodes[i].getContent();
+               // If previous node local_id was found and same than before, don't lookup maps
+               // apply directly previous resolved id
+               // This permits to massively improve loading performance when nodes are similar
+               // example: default:air, default:stone are massively present
+               if (previous_exists && local_id == previous_local_id) {
+                       nodes[i].setContent(previous_global_id);
+                       continue;
                }
                }
-               compress(materialdata, os, version);
 
 
-               // Get and compress lights
-               SharedBuffer<u8> lightdata(nodecount);
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       lightdata[i] = data[i].param;
+               std::string name;
+               if (!nimap->getName(local_id, name)) {
+                       unnamed_contents.insert(local_id);
+                       previous_exists = false;
+                       continue;
                }
                }
-               compress(lightdata, os, version);
-               
-               if(version >= 10)
-               {
-                       // Get and compress param2
-                       SharedBuffer<u8> param2data(nodecount);
-                       for(u32 i=0; i<nodecount; i++)
-                       {
-                               param2data[i] = data[i].param2;
+
+               content_t global_id;
+               if (!nodedef->getId(name, global_id)) {
+                       global_id = gamedef->allocateUnknownNodeId(name);
+                       if (global_id == CONTENT_IGNORE) {
+                               unallocatable_contents.insert(name);
+                               previous_exists = false;
+                               continue;
                        }
                        }
-                       compress(param2data, os, version);
                }
                }
+               nodes[i].setContent(global_id);
+
+               // Save previous node local_id & global_id result
+               previous_local_id = local_id;
+               previous_global_id = global_id;
+               previous_exists = true;
        }
        }
-       // All other versions (newest)
-       else
-       {
-               // First byte
-               u8 flags = 0;
-               if(is_underground)
-                       flags |= 0x01;
-               if(m_day_night_differs)
-                       flags |= 0x02;
-               if(m_lighting_expired)
-                       flags |= 0x04;
-               if(version >= 18)
-               {
-                       if(m_generated == false)
-                               flags |= 0x08;
-               }
-               os.write((char*)&flags, 1);
 
 
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+       for (const content_t c: unnamed_contents) {
+               errorstream << "correctBlockNodeIds(): IGNORING ERROR: "
+                               << "Block contains id " << c
+                               << " with no name mapping" << std::endl;
+       }
+       for (const std::string &node_name: unallocatable_contents) {
+               errorstream << "correctBlockNodeIds(): IGNORING ERROR: "
+                               << "Could not allocate global id for node name \""
+                               << node_name << "\"" << std::endl;
+       }
+}
 
 
-               /*
-                       Get data
-               */
+void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
+{
+       if(!ser_ver_supported(version))
+               throw VersionMismatchException("ERROR: MapBlock format not supported");
 
 
-               SharedBuffer<u8> databuf(nodecount*3);
+       if (!data)
+               throw SerializationError("ERROR: Not writing dummy block.");
 
 
-               // Get contents
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       databuf[i] = data[i].d;
-               }
+       FATAL_ERROR_IF(version < SER_FMT_VER_LOWEST_WRITE, "Serialisation version error");
+
+       // First byte
+       u8 flags = 0;
+       if(is_underground)
+               flags |= 0x01;
+       if(getDayNightDiff())
+               flags |= 0x02;
+       if (!m_generated)
+               flags |= 0x08;
+       writeU8(os, flags);
+       if (version >= 27) {
+               writeU16(os, m_lighting_complete);
+       }
 
 
-               // Get params
+       /*
+               Bulk node data
+       */
+       NameIdMapping nimap;
+       if(disk)
+       {
+               MapNode *tmp_nodes = new MapNode[nodecount];
                for(u32 i=0; i<nodecount; i++)
                for(u32 i=0; i<nodecount; i++)
-               {
-                       databuf[i+nodecount] = data[i].param;
-               }
+                       tmp_nodes[i] = data[i];
+               getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef());
+
+               u8 content_width = 2;
+               u8 params_width = 2;
+               writeU8(os, content_width);
+               writeU8(os, params_width);
+               MapNode::serializeBulk(os, version, tmp_nodes, nodecount,
+                               content_width, params_width, true);
+               delete[] tmp_nodes;
+       }
+       else
+       {
+               u8 content_width = 2;
+               u8 params_width = 2;
+               writeU8(os, content_width);
+               writeU8(os, params_width);
+               MapNode::serializeBulk(os, version, data, nodecount,
+                               content_width, params_width, true);
+       }
 
 
-               // Get param2
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       databuf[i+nodecount*2] = data[i].param2;
+       /*
+               Node metadata
+       */
+       std::ostringstream oss(std::ios_base::binary);
+       m_node_metadata.serialize(oss, version, disk);
+       compressZlib(oss.str(), os);
+
+       /*
+               Data that goes to disk, but not the network
+       */
+       if(disk)
+       {
+               if(version <= 24){
+                       // Node timers
+                       m_node_timers.serialize(os, version);
                }
 
                }
 
-               /*
-                       Compress data to output stream
-               */
+               // Static objects
+               m_static_objects.serialize(os);
 
 
-               compress(databuf, os, version);
-               
-               /*
-                       NodeMetadata
-               */
-               if(version >= 14)
-               {
-                       if(version <= 15)
-                       {
-                               try{
-                                       std::ostringstream oss(std::ios_base::binary);
-                                       m_node_metadata.serialize(oss);
-                                       os<<serializeString(oss.str());
-                               }
-                               // This will happen if the string is longer than 65535
-                               catch(SerializationError &e)
-                               {
-                                       // Use an empty string
-                                       os<<serializeString("");
-                               }
-                       }
-                       else
-                       {
-                               std::ostringstream oss(std::ios_base::binary);
-                               m_node_metadata.serialize(oss);
-                               compressZlib(oss.str(), os);
-                               //os<<serializeLongString(oss.str());
-                       }
+               // Timestamp
+               writeU32(os, getTimestamp());
+
+               // Write block-specific node definition id mapping
+               nimap.serialize(os);
+
+               if(version >= 25){
+                       // Node timers
+                       m_node_timers.serialize(os, version);
                }
        }
 }
 
                }
        }
 }
 
-void MapBlock::deSerialize(std::istream &is, u8 version)
+void MapBlock::serializeNetworkSpecific(std::ostream &os)
+{
+       if (!data) {
+               throw SerializationError("ERROR: Not writing dummy block.");
+       }
+
+       writeU8(os, 1); // version
+       writeF1000(os, 0); // deprecated heat
+       writeF1000(os, 0); // deprecated humidity
+}
+
+void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
 {
        if(!ser_ver_supported(version))
                throw VersionMismatchException("ERROR: MapBlock format not supported");
 
 {
        if(!ser_ver_supported(version))
                throw VersionMismatchException("ERROR: MapBlock format not supported");
 
-       // These have no lighting info
-       if(version <= 1)
+       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl);
+
+       m_day_night_differs_expired = false;
+
+       if(version <= 21)
        {
        {
-               setLightingExpired(true);
+               deSerialize_pre22(is, version, disk);
+               return;
        }
 
        }
 
-       // These have no "generated" field
-       if(version < 18)
-       {
-               m_generated = true;
+       u8 flags = readU8(is);
+       is_underground = (flags & 0x01) != 0;
+       m_day_night_differs = (flags & 0x02) != 0;
+       if (version < 27)
+               m_lighting_complete = 0xFFFF;
+       else
+               m_lighting_complete = readU16(is);
+       m_generated = (flags & 0x08) == 0;
+
+       /*
+               Bulk node data
+       */
+       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                       <<": Bulk node data"<<std::endl);
+       u8 content_width = readU8(is);
+       u8 params_width = readU8(is);
+       if(content_width != 1 && content_width != 2)
+               throw SerializationError("MapBlock::deSerialize(): invalid content_width");
+       if(params_width != 2)
+               throw SerializationError("MapBlock::deSerialize(): invalid params_width");
+       MapNode::deSerializeBulk(is, version, data, nodecount,
+                       content_width, params_width, true);
+
+       /*
+               NodeMetadata
+       */
+       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                       <<": Node metadata"<<std::endl);
+       // Ignore errors
+       try {
+               std::ostringstream oss(std::ios_base::binary);
+               decompressZlib(is, oss);
+               std::istringstream iss(oss.str(), std::ios_base::binary);
+               if (version >= 23)
+                       m_node_metadata.deSerialize(iss, m_gamedef->idef());
+               else
+                       content_nodemeta_deserialize_legacy(iss,
+                               &m_node_metadata, &m_node_timers,
+                               m_gamedef->idef());
+       } catch(SerializationError &e) {
+               warningstream<<"MapBlock::deSerialize(): Ignoring an error"
+                               <<" while deserializing node metadata at ("
+                               <<PP(getPos())<<": "<<e.what()<<std::endl;
        }
 
        }
 
-       // These have no compression
-       if(version <= 3 || version == 5 || version == 6)
+       /*
+               Data that is only on disk
+       */
+       if(disk)
        {
        {
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-               char tmp;
-               is.read(&tmp, 1);
-               if(is.gcount() != 1)
-                       throw SerializationError
-                                       ("MapBlock::deSerialize: no enough input data");
-               is_underground = tmp;
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       s32 len = MapNode::serializedLength(version);
-                       SharedBuffer<u8> d(len);
-                       is.read((char*)*d, len);
-                       if(is.gcount() != len)
-                               throw SerializationError
-                                               ("MapBlock::deSerialize: no enough input data");
-                       data[i].deSerialize(*d, version);
+               // Node timers
+               if(version == 23){
+                       // Read unused zero
+                       readU8(is);
+               }
+               if(version == 24){
+                       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                                       <<": Node timers (ver==24)"<<std::endl);
+                       m_node_timers.deSerialize(is, version);
+               }
+
+               // Static objects
+               TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                               <<": Static objects"<<std::endl);
+               m_static_objects.deSerialize(is);
+
+               // Timestamp
+               TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                               <<": Timestamp"<<std::endl);
+               setTimestamp(readU32(is));
+               m_disk_timestamp = m_timestamp;
+
+               // Dynamically re-set ids based on node names
+               TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                               <<": NameIdMapping"<<std::endl);
+               NameIdMapping nimap;
+               nimap.deSerialize(is);
+               correctBlockNodeIds(&nimap, data, m_gamedef);
+
+               if(version >= 25){
+                       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                                       <<": Node timers (ver>=25)"<<std::endl);
+                       m_node_timers.deSerialize(is, version);
                }
        }
                }
        }
-       else if(version <= 10)
+
+       TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+                       <<": Done."<<std::endl);
+}
+
+void MapBlock::deSerializeNetworkSpecific(std::istream &is)
+{
+       try {
+               int version = readU8(is);
+               //if(version != 1)
+               //      throw SerializationError("unsupported MapBlock version");
+               if(version >= 1) {
+                       readF1000(is); // deprecated heat
+                       readF1000(is); // deprecated humidity
+               }
+       }
+       catch(SerializationError &e)
        {
        {
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+               warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+                               <<": "<<e.what()<<std::endl;
+       }
+}
+
+/*
+       Legacy serialization
+*/
+
+void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
+{
+       // Initialize default flags
+       is_underground = false;
+       m_day_night_differs = false;
+       m_lighting_complete = 0xFFFF;
+       m_generated = true;
 
 
+       // Make a temporary buffer
+       u32 ser_length = MapNode::serializedLength(version);
+       SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
+
+       // These have no compression
+       if (version <= 3 || version == 5 || version == 6) {
+               char tmp;
+               is.read(&tmp, 1);
+               if (is.gcount() != 1)
+                       throw SerializationError(std::string(FUNCTION_NAME)
+                               + ": not enough input data");
+               is_underground = tmp;
+               is.read((char *)*databuf_nodelist, nodecount * ser_length);
+               if ((u32)is.gcount() != nodecount * ser_length)
+                       throw SerializationError(std::string(FUNCTION_NAME)
+                               + ": not enough input data");
+       } else if (version <= 10) {
                u8 t8;
                u8 t8;
-               is.read((char*)&t8, 1);
+               is.read((char *)&t8, 1);
                is_underground = t8;
 
                {
                is_underground = t8;
 
                {
@@ -714,12 +802,11 @@ void MapBlock::deSerialize(std::istream &is, u8 version)
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
-                       if(s.size() != nodecount)
-                               throw SerializationError
-                                               ("MapBlock::deSerialize: invalid format");
-                       for(u32 i=0; i<s.size(); i++)
-                       {
-                               data[i].d = s[i];
+                       if (s.size() != nodecount)
+                               throw SerializationError(std::string(FUNCTION_NAME)
+                                       + ": not enough input data");
+                       for (u32 i = 0; i < s.size(); i++) {
+                               databuf_nodelist[i*ser_length] = s[i];
                        }
                }
                {
                        }
                }
                {
@@ -727,168 +814,258 @@ void MapBlock::deSerialize(std::istream &is, u8 version)
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
-                       if(s.size() != nodecount)
-                               throw SerializationError
-                                               ("MapBlock::deSerialize: invalid format");
-                       for(u32 i=0; i<s.size(); i++)
-                       {
-                               data[i].param = s[i];
+                       if (s.size() != nodecount)
+                               throw SerializationError(std::string(FUNCTION_NAME)
+                                       + ": not enough input data");
+                       for (u32 i = 0; i < s.size(); i++) {
+                               databuf_nodelist[i*ser_length + 1] = s[i];
                        }
                }
                        }
                }
-       
-               if(version >= 10)
-               {
+
+               if (version >= 10) {
                        // Uncompress and set param2 data
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
                        // Uncompress and set param2 data
                        std::ostringstream os(std::ios_base::binary);
                        decompress(is, os, version);
                        std::string s = os.str();
-                       if(s.size() != nodecount)
-                               throw SerializationError
-                                               ("MapBlock::deSerialize: invalid format");
-                       for(u32 i=0; i<s.size(); i++)
-                       {
-                               data[i].param2 = s[i];
+                       if (s.size() != nodecount)
+                               throw SerializationError(std::string(FUNCTION_NAME)
+                                       + ": not enough input data");
+                       for (u32 i = 0; i < s.size(); i++) {
+                               databuf_nodelist[i*ser_length + 2] = s[i];
                        }
                }
                        }
                }
-       }
-       // All other versions (newest)
-       else
-       {
-               u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
+       } else { // All other versions (10 to 21)
                u8 flags;
                is.read((char*)&flags, 1);
                u8 flags;
                is.read((char*)&flags, 1);
-               is_underground = (flags & 0x01) ? true : false;
-               m_day_night_differs = (flags & 0x02) ? true : false;
-               m_lighting_expired = (flags & 0x04) ? true : false;
+               is_underground = (flags & 0x01) != 0;
+               m_day_night_differs = (flags & 0x02) != 0;
                if(version >= 18)
                if(version >= 18)
-                       m_generated = (flags & 0x08) ? false : true;
+                       m_generated = (flags & 0x08) == 0;
 
                // Uncompress data
                std::ostringstream os(std::ios_base::binary);
                decompress(is, os, version);
                std::string s = os.str();
 
                // Uncompress data
                std::ostringstream os(std::ios_base::binary);
                decompress(is, os, version);
                std::string s = os.str();
-               if(s.size() != nodecount*3)
-                       throw SerializationError
-                                       ("MapBlock::deSerialize: decompress resulted in size"
-                                       " other than nodecount*3");
-
-               // Set contents
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       data[i].d = s[i];
-               }
-               // Set params
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       data[i].param = s[i+nodecount];
-               }
-               // Set param2
-               for(u32 i=0; i<nodecount; i++)
-               {
-                       data[i].param2 = s[i+nodecount*2];
+               if (s.size() != nodecount * 3)
+                       throw SerializationError(std::string(FUNCTION_NAME)
+                               + ": decompress resulted in size other than nodecount*3");
+
+               // deserialize nodes from buffer
+               for (u32 i = 0; i < nodecount; i++) {
+                       databuf_nodelist[i*ser_length] = s[i];
+                       databuf_nodelist[i*ser_length + 1] = s[i+nodecount];
+                       databuf_nodelist[i*ser_length + 2] = s[i+nodecount*2];
                }
                }
-               
+
                /*
                        NodeMetadata
                */
                /*
                        NodeMetadata
                */
-               if(version >= 14)
-               {
+               if (version >= 14) {
                        // Ignore errors
                        // Ignore errors
-                       try{
-                               if(version <= 15)
-                               {
+                       try {
+                               if (version <= 15) {
                                        std::string data = deSerializeString(is);
                                        std::istringstream iss(data, std::ios_base::binary);
                                        std::string data = deSerializeString(is);
                                        std::istringstream iss(data, std::ios_base::binary);
-                                       m_node_metadata.deSerialize(iss);
-                               }
-                               else
-                               {
+                                       content_nodemeta_deserialize_legacy(iss,
+                                               &m_node_metadata, &m_node_timers,
+                                               m_gamedef->idef());
+                               } else {
                                        //std::string data = deSerializeLongString(is);
                                        std::ostringstream oss(std::ios_base::binary);
                                        decompressZlib(is, oss);
                                        std::istringstream iss(oss.str(), std::ios_base::binary);
                                        //std::string data = deSerializeLongString(is);
                                        std::ostringstream oss(std::ios_base::binary);
                                        decompressZlib(is, oss);
                                        std::istringstream iss(oss.str(), std::ios_base::binary);
-                                       m_node_metadata.deSerialize(iss);
+                                       content_nodemeta_deserialize_legacy(iss,
+                                               &m_node_metadata, &m_node_timers,
+                                               m_gamedef->idef());
                                }
                                }
-                       }
-                       catch(SerializationError &e)
-                       {
-                               dstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+                       } catch(SerializationError &e) {
+                               warningstream<<"MapBlock::deSerialize(): Ignoring an error"
                                                <<" while deserializing node metadata"<<std::endl;
                        }
                }
        }
                                                <<" while deserializing node metadata"<<std::endl;
                        }
                }
        }
-       
-       /*
-               Translate nodes as specified in the translate_to fields of
-               node features
 
 
-               NOTE: This isn't really used. Should it be removed?
-       */
-       for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-       {
-               MapNode &n = data[i];
+       // Deserialize node data
+       for (u32 i = 0; i < nodecount; i++) {
+               data[i].deSerialize(&databuf_nodelist[i * ser_length], version);
+       }
 
 
-               MapNode *translate_to = content_features(n.d).translate_to;
-               if(translate_to)
-               {
-                       dstream<<"MapBlock: WARNING: Translating node "<<n.d<<" to "
-                                       <<translate_to->d<<std::endl;
-                       n = *translate_to;
+       if (disk) {
+               /*
+                       Versions up from 9 have block objects. (DEPRECATED)
+               */
+               if (version >= 9) {
+                       u16 count = readU16(is);
+                       // Not supported and length not known if count is not 0
+                       if(count != 0){
+                               warningstream<<"MapBlock::deSerialize_pre22(): "
+                                               <<"Ignoring stuff coming at and after MBOs"<<std::endl;
+                               return;
+                       }
                }
                }
-       }
-}
 
 
-void MapBlock::serializeDiskExtra(std::ostream &os, u8 version)
-{
-       // Versions up from 9 have block objects.
-       if(version >= 9)
-       {
-               //serializeObjects(os, version); // DEPRECATED
-               // count=0
-               writeU16(os, 0);
-       }
-       
-       // Versions up from 15 have static objects.
-       if(version >= 15)
-       {
-               m_static_objects.serialize(os);
+               /*
+                       Versions up from 15 have static objects.
+               */
+               if (version >= 15)
+                       m_static_objects.deSerialize(is);
+
+               // Timestamp
+               if (version >= 17) {
+                       setTimestamp(readU32(is));
+                       m_disk_timestamp = m_timestamp;
+               } else {
+                       setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+               }
+
+               // Dynamically re-set ids based on node names
+               NameIdMapping nimap;
+               // If supported, read node definition id mapping
+               if (version >= 21) {
+                       nimap.deSerialize(is);
+               // Else set the legacy mapping
+               } else {
+                       content_mapnode_get_name_id_mapping(&nimap);
+               }
+               correctBlockNodeIds(&nimap, data, m_gamedef);
        }
 
        }
 
-       // Timestamp
-       if(version >= 17)
+
+       // Legacy data changes
+       // This code has to convert from pre-22 to post-22 format.
+       INodeDefManager *nodedef = m_gamedef->ndef();
+       for(u32 i=0; i<nodecount; i++)
        {
        {
-               writeU32(os, getTimestamp());
+               const ContentFeatures &f = nodedef->get(data[i].getContent());
+               // Mineral
+               if(nodedef->getId("default:stone") == data[i].getContent()
+                               && data[i].getParam1() == 1)
+               {
+                       data[i].setContent(nodedef->getId("default:stone_with_coal"));
+                       data[i].setParam1(0);
+               }
+               else if(nodedef->getId("default:stone") == data[i].getContent()
+                               && data[i].getParam1() == 2)
+               {
+                       data[i].setContent(nodedef->getId("default:stone_with_iron"));
+                       data[i].setParam1(0);
+               }
+               // facedir_simple
+               if(f.legacy_facedir_simple)
+               {
+                       data[i].setParam2(data[i].getParam1());
+                       data[i].setParam1(0);
+               }
+               // wall_mounted
+               if(f.legacy_wallmounted)
+               {
+                       u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0};
+                       u8 dir_old_format = data[i].getParam2();
+                       u8 dir_new_format = 0;
+                       for(u8 j=0; j<8; j++)
+                       {
+                               if((dir_old_format & wallmounted_new_to_old[j]) != 0)
+                               {
+                                       dir_new_format = j;
+                                       break;
+                               }
+                       }
+                       data[i].setParam2(dir_new_format);
+               }
        }
        }
+
 }
 
 }
 
-void MapBlock::deSerializeDiskExtra(std::istream &is, u8 version)
+/*
+       Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block)
 {
 {
-       /*
-               Versions up from 9 have block objects.
-       */
-       if(version >= 9)
-       {
-               updateObjects(is, version, NULL, 0);
-       }
+       if(block == NULL)
+               return "NULL";
 
 
-       /*
-               Versions up from 15 have static objects.
-       */
-       if(version >= 15)
+       std::ostringstream desc;
+
+       v3s16 p = block->getPos();
+       char spos[25];
+       snprintf(spos, sizeof(spos), "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+       desc<<spos;
+
+       switch(block->getModified())
        {
        {
-               m_static_objects.deSerialize(is);
+       case MOD_STATE_CLEAN:
+               desc<<"CLEAN,           ";
+               break;
+       case MOD_STATE_WRITE_AT_UNLOAD:
+               desc<<"WRITE_AT_UNLOAD, ";
+               break;
+       case MOD_STATE_WRITE_NEEDED:
+               desc<<"WRITE_NEEDED,    ";
+               break;
+       default:
+               desc<<"unknown getModified()="+itos(block->getModified())+", ";
        }
        }
-               
-       // Timestamp
-       if(version >= 17)
+
+       if(block->isGenerated())
+               desc<<"is_gen [X], ";
+       else
+               desc<<"is_gen [ ], ";
+
+       if(block->getIsUnderground())
+               desc<<"is_ug [X], ";
+       else
+               desc<<"is_ug [ ], ";
+
+       desc<<"lighting_complete: "<<block->getLightingComplete()<<", ";
+
+       if(block->isDummy())
        {
        {
-               setTimestamp(readU32(is));
+               desc<<"Dummy, ";
        }
        else
        {
        }
        else
        {
-               setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+               bool full_ignore = true;
+               bool some_ignore = false;
+               bool full_air = true;
+               bool some_air = false;
+               for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+               for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+               for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+               {
+                       v3s16 p(x0,y0,z0);
+                       MapNode n = block->getNodeNoEx(p);
+                       content_t c = n.getContent();
+                       if(c == CONTENT_IGNORE)
+                               some_ignore = true;
+                       else
+                               full_ignore = false;
+                       if(c == CONTENT_AIR)
+                               some_air = true;
+                       else
+                               full_air = false;
+               }
+
+               desc<<"content {";
+
+               std::ostringstream ss;
+
+               if(full_ignore)
+                       ss<<"IGNORE (full), ";
+               else if(some_ignore)
+                       ss<<"IGNORE, ";
+
+               if(full_air)
+                       ss<<"AIR (full), ";
+               else if(some_air)
+                       ss<<"AIR, ";
+
+               if(ss.str().size()>=2)
+                       desc<<ss.str().substr(0, ss.str().size()-2);
+
+               desc<<"}, ";
        }
        }
+
+       return desc.str().substr(0, desc.str().size()-2);
 }
 
 
 }
 
 
Dragonfireclient is an utility client for the Voxelengine minetest (http://minetest.net/). The client was created by Elias Fleckenstein and is inspired by the Minecraft clients Liquid Bounce and Impact. Discord: https://discord.gg/kab99uu for more information.