]> 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 bd2e19b41b0de8c6f158e4a65f23843d6f8ea9bc..88f04e0bb56a0b14f14edf43839a694786279a5a 100644 (file)
--- a/src/mapblock.cpp
+++ b/src/mapblock.cpp
@@ -21,8 +21,6 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 
 #include <sstream>
 #include "map.h"
 
 #include <sstream>
 #include "map.h"
-// For g_settings
-#include "main.h"
 #include "light.h"
 #include "nodedef.h"
 #include "nodemetadata.h"
 #include "light.h"
 #include "nodedef.h"
 #include "nodemetadata.h"
@@ -31,132 +29,113 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "nameidmapping.h"
 #include "content_mapnode.h" // For legacy name-id mapping
 #include "content_nodemeta.h" // For legacy deserialization
 #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"
 #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",
+};
 
 
-#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
 
 /*
        MapBlock
 */
 
 MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
 
 /*
        MapBlock
 */
 
 MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
-               heat(0),
-               heat_time(0),
-               humidity(0),
-               humidity_time(0),
                m_parent(parent),
                m_pos(pos),
                m_parent(parent),
                m_pos(pos),
-               m_gamedef(gamedef),
-               m_modified(MOD_STATE_WRITE_NEEDED),
-               m_modified_reason("initial"),
-               m_modified_reason_too_long(false),
-               is_underground(false),
-               m_lighting_expired(true),
-               m_day_night_differs(false),
-               m_day_night_differs_expired(true),
-               m_generated(false),
-               m_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
-               m_disk_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
-               m_usage_timer(0),
-               m_refcount(0)
+               m_pos_relative(pos * MAP_BLOCKSIZE),
+               m_gamedef(gamedef)
 {
 {
-       data = NULL;
-       if(dummy == false)
+       if (!dummy)
                reallocate();
                reallocate();
-       
-#ifndef SERVER
-       //mesh_mutex.Init();
-       mesh = NULL;
-#endif
 }
 
 MapBlock::~MapBlock()
 {
 #ifndef SERVER
        {
 }
 
 MapBlock::~MapBlock()
 {
 #ifndef SERVER
        {
-               //JMutexAutoLock lock(mesh_mutex);
-               
-               if(mesh)
-               {
-                       delete mesh;
-                       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);
+
+       if (!data) {
+               if (is_valid_position)
+                       *is_valid_position = false;
+               return {CONTENT_IGNORE};
        }
        }
+       if (is_valid_position)
+               *is_valid_position = true;
+       return data[p.Z * zstride + p.Y * ystride + p.X];
 }
 
 }
 
-MapNode MapBlock::getNodeParentNoEx(v3s16 p)
+std::string MapBlock::getModifiedReasonString()
 {
 {
-       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];
+       std::string reason;
+
+       const u32 ubound = MYMIN(sizeof(m_modified_reason) * CHAR_BIT,
+               ARRLEN(modified_reason_strings));
+
+       for (u32 i = 0; i != ubound; i++) {
+               if ((m_modified_reason & (1 << i)) == 0)
+                       continue;
+
+               reason += modified_reason_strings[i];
+               reason += ", ";
        }
        }
+
+       if (reason.length() > 2)
+               reason.resize(reason.length() - 2);
+
+       return reason;
 }
 
 /*
        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.
@@ -179,19 +158,24 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
 
        // 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));
+
+                       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
                                if(n.getContent() == CONTENT_IGNORE)
                                {
                                        // Trust heuristics
@@ -202,10 +186,10 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
                                        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)
@@ -214,9 +198,8 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
                                }
                                else
                                {
                                }
                                else
                                {
-                                       MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
-                                       if(m_gamedef->ndef()->get(n).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;
                                        }
                                }
@@ -247,19 +230,19 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & 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
@@ -267,12 +250,10 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
                                else if(current_light == LIGHT_SUN && nodemgr->get(n).sunlight_propagates)
                                {
                                        // Do nothing: Sunlight is continued
                                else if(current_light == LIGHT_SUN && nodemgr->get(n).sunlight_propagates)
                                {
                                        // Do nothing: Sunlight is continued
-                               }
-                               else if(nodemgr->get(n).light_propagates == false)
-                               {
+                               } 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;
                                }
@@ -288,7 +269,7 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & light_sources,
                                {
                                        n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
                                }
                                {
                                        n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
                                }
-                               
+
                                if(diminish_light(current_light) != 0)
                                {
                                        light_sources.insert(pos_relative + pos);
                                if(diminish_light(current_light) != 0)
                                {
                                        light_sources.insert(pos_relative + pos);
@@ -311,30 +292,30 @@ bool MapBlock::propagateSunlight(std::set<v3s16> & 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(nodemgr->get(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, nodemgr) == LIGHT_SUN
-                                                       && sunlight_should_go_down == false)
-                                               block_below_is_valid = false;
-                                       else if(n.getLight(LIGHTBANK_DAY, nodemgr) != 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.
                        }
                }
        }
                        }
                }
        }
@@ -347,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);
@@ -357,7 +338,7 @@ 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);
@@ -366,11 +347,11 @@ void MapBlock::copyFrom(VoxelManipulator &dst)
 void MapBlock::actuallyUpdateDayNightDiff()
 {
        INodeDefManager *nodemgr = m_gamedef->ndef();
 void MapBlock::actuallyUpdateDayNightDiff()
 {
        INodeDefManager *nodemgr = m_gamedef->ndef();
+
        // Running this function un-expires m_day_night_differs
        m_day_night_differs_expired = false;
 
        // Running this function un-expires m_day_night_differs
        m_day_night_differs_expired = false;
 
-       if(data == NULL)
-       {
+       if (!data) {
                m_day_night_differs = false;
                return;
        }
                m_day_night_differs = false;
                return;
        }
@@ -380,33 +361,35 @@ void MapBlock::actuallyUpdateDayNightDiff()
        /*
                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, nodemgr) != n.getLight(LIGHTBANK_NIGHT, nodemgr))
-               {
-                       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.getContent() != 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;
        }
 
@@ -416,9 +399,7 @@ void MapBlock::actuallyUpdateDayNightDiff()
 
 void MapBlock::expireDayNightDiff()
 {
 
 void MapBlock::expireDayNightDiff()
 {
-       //INodeDefManager *nodemgr = m_gamedef->ndef();
-
-       if(data == NULL){
+       if (!data) {
                m_day_night_differs = false;
                m_day_night_differs_expired = false;
                return;
                m_day_night_differs = false;
                m_day_night_differs_expired = false;
                return;
@@ -437,12 +418,11 @@ s16 MapBlock::getGroundLevel(v2s16 p2d)
                for(; y>=0; y--)
                {
                        MapNode n = getNodeRef(p2d.X, y, p2d.Y);
                for(; y>=0; y--)
                {
                        MapNode n = getNodeRef(p2d.X, y, p2d.Y);
-                       if(m_gamedef->ndef()->get(n).walkable)
-                       {
+                       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;
@@ -458,32 +438,35 @@ s16 MapBlock::getGroundLevel(v2s16 p2d)
 */
 // List relevant id-name pairs for ids in the block using nodedef
 // Renumbers the content IDs (starting at 0 and incrementing
 */
 // 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)
 {
 static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
                INodeDefManager *nodedef)
 {
-       std::map<content_t, content_t> mapping;
+       memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t));
+
        std::set<content_t> unknown_contents;
        content_t id_counter = 0;
        std::set<content_t> unknown_contents;
        content_t id_counter = 0;
-       for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-       {
+       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
                content_t global_id = nodes[i].getContent();
                content_t id = CONTENT_IGNORE;
 
                // Try to find an existing mapping
-               std::map<content_t, content_t>::iterator j = mapping.find(global_id);
-               if(j != mapping.end())
-               {
-                       id = j->second;
+               if (getBlockNodeIdMapping_mapping[global_id] != 0xFFFF) {
+                       id = getBlockNodeIdMapping_mapping[global_id];
                }
                else
                {
                        // We have to assign a new mapping
                        id = id_counter++;
                }
                else
                {
                        // We have to assign a new mapping
                        id = id_counter++;
-                       mapping.insert(std::make_pair(global_id, id));
+                       getBlockNodeIdMapping_mapping[global_id] = id;
 
                        const ContentFeatures &f = nodedef->get(global_id);
                        const std::string &name = f.name;
 
                        const ContentFeatures &f = nodedef->get(global_id);
                        const std::string &name = f.name;
-                       if(name == "")
+                       if (name.empty())
                                unknown_contents.insert(global_id);
                        else
                                nimap->set(id, name);
                                unknown_contents.insert(global_id);
                        else
                                nimap->set(id, name);
@@ -492,11 +475,9 @@ static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
                // Update the MapNode
                nodes[i].setContent(id);
        }
                // Update the MapNode
                nodes[i].setContent(id);
        }
-       for(std::set<content_t>::const_iterator
-                       i = unknown_contents.begin();
-                       i != unknown_contents.end(); i++){
-               errorstream<<"getBlockNodeIdMapping(): IGNORING ERROR: "
-                               <<"Name for node id "<<(*i)<<" not known"<<std::endl;
+       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.
        }
 }
 // Correct ids in the block to match nodedef based on names.
@@ -510,41 +491,57 @@ static void correctBlockNodeIds(const NameIdMapping *nimap, MapNode *nodes,
        // the information to convert those to names.
        // nodedef contains information to convert our names to globally
        // correct ids.
        // the information to convert those to names.
        // nodedef contains information to convert our names to globally
        // correct ids.
-       std::set<content_t> unnamed_contents;
-       std::set<std::string> unallocatable_contents;
-       for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-       {
+       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();
                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;
+               }
+
                std::string name;
                std::string name;
-               bool found = nimap->getName(local_id, name);
-               if(!found){
+               if (!nimap->getName(local_id, name)) {
                        unnamed_contents.insert(local_id);
                        unnamed_contents.insert(local_id);
+                       previous_exists = false;
                        continue;
                }
                        continue;
                }
+
                content_t global_id;
                content_t global_id;
-               found = nodedef->getId(name, global_id);
-               if(!found){
+               if (!nodedef->getId(name, global_id)) {
                        global_id = gamedef->allocateUnknownNodeId(name);
                        global_id = gamedef->allocateUnknownNodeId(name);
-                       if(global_id == CONTENT_IGNORE){
+                       if (global_id == CONTENT_IGNORE) {
                                unallocatable_contents.insert(name);
                                unallocatable_contents.insert(name);
+                               previous_exists = false;
                                continue;
                        }
                }
                nodes[i].setContent(global_id);
                                continue;
                        }
                }
                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;
        }
        }
-       for(std::set<content_t>::const_iterator
-                       i = unnamed_contents.begin();
-                       i != unnamed_contents.end(); i++){
-               errorstream<<"correctBlockNodeIds(): IGNORING ERROR: "
-                               <<"Block contains id "<<(*i)
-                               <<" with no name mapping"<<std::endl;
+
+       for (const content_t c: unnamed_contents) {
+               errorstream << "correctBlockNodeIds(): IGNORING ERROR: "
+                               << "Block contains id " << c
+                               << " with no name mapping" << std::endl;
        }
        }
-       for(std::set<std::string>::const_iterator
-                       i = unallocatable_contents.begin();
-                       i != unallocatable_contents.end(); i++){
-               errorstream<<"correctBlockNodeIds(): IGNORING ERROR: "
-                               <<"Could not allocate global id for node name \""
-                               <<(*i)<<"\""<<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;
        }
 }
 
        }
 }
 
@@ -552,35 +549,29 @@ void MapBlock::serialize(std::ostream &os, 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");
-       
-       if(data == NULL)
-       {
+
+       if (!data)
                throw SerializationError("ERROR: Not writing dummy block.");
                throw SerializationError("ERROR: Not writing dummy block.");
-       }
-       
-       // Can't do this anymore; we have 16-bit dynamically allocated node IDs
-       // in memory; conversion just won't work in this direction.
-       if(version < 24)
-               throw SerializationError("MapBlock::serialize: serialization to "
-                               "version < 24 not possible");
-               
+
+       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;
        // First byte
        u8 flags = 0;
        if(is_underground)
                flags |= 0x01;
        if(getDayNightDiff())
                flags |= 0x02;
-       if(m_lighting_expired)
-               flags |= 0x04;
-       if(m_generated == false)
+       if (!m_generated)
                flags |= 0x08;
        writeU8(os, flags);
                flags |= 0x08;
        writeU8(os, flags);
-       
+       if (version >= 27) {
+               writeU16(os, m_lighting_complete);
+       }
+
        /*
                Bulk node data
        */
        NameIdMapping nimap;
        /*
                Bulk node data
        */
        NameIdMapping nimap;
-       u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
        if(disk)
        {
                MapNode *tmp_nodes = new MapNode[nodecount];
        if(disk)
        {
                MapNode *tmp_nodes = new MapNode[nodecount];
@@ -605,12 +596,12 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
                MapNode::serializeBulk(os, version, data, nodecount,
                                content_width, params_width, true);
        }
                MapNode::serializeBulk(os, version, data, nodecount,
                                content_width, params_width, true);
        }
-       
+
        /*
                Node metadata
        */
        std::ostringstream oss(std::ios_base::binary);
        /*
                Node metadata
        */
        std::ostringstream oss(std::ios_base::binary);
-       m_node_metadata.serialize(oss);
+       m_node_metadata.serialize(oss, version, disk);
        compressZlib(oss.str(), os);
 
        /*
        compressZlib(oss.str(), os);
 
        /*
@@ -631,24 +622,30 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
 
                // Write block-specific node definition id mapping
                nimap.serialize(os);
 
                // Write block-specific node definition id mapping
                nimap.serialize(os);
-               
+
                if(version >= 25){
                        // Node timers
                        m_node_timers.serialize(os, version);
                }
                if(version >= 25){
                        // Node timers
                        m_node_timers.serialize(os, version);
                }
-       } else {
-               if(version >= 26){
-                       writeF1000(os, heat);
-                       writeF1000(os, humidity);
-               }
        }
 }
 
        }
 }
 
+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");
 void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
 {
        if(!ser_ver_supported(version))
                throw VersionMismatchException("ERROR: MapBlock format not supported");
-       
+
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl);
 
        m_day_night_differs_expired = false;
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())<<std::endl);
 
        m_day_night_differs_expired = false;
@@ -660,17 +657,19 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
        }
 
        u8 flags = readU8(is);
        }
 
        u8 flags = readU8(is);
-       is_underground = (flags & 0x01) ? true : false;
-       m_day_night_differs = (flags & 0x02) ? true : false;
-       m_lighting_expired = (flags & 0x04) ? true : false;
-       m_generated = (flags & 0x08) ? false : true;
+       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);
 
        /*
                Bulk node data
        */
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                        <<": Bulk node data"<<std::endl);
-       u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
        u8 content_width = readU8(is);
        u8 params_width = readU8(is);
        if(content_width != 1 && content_width != 2)
        u8 content_width = readU8(is);
        u8 params_width = readU8(is);
        if(content_width != 1 && content_width != 2)
@@ -686,20 +685,18 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                        <<": Node metadata"<<std::endl);
        // Ignore errors
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                        <<": Node metadata"<<std::endl);
        // Ignore errors
-       try{
+       try {
                std::ostringstream oss(std::ios_base::binary);
                decompressZlib(is, oss);
                std::istringstream iss(oss.str(), std::ios_base::binary);
                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);
+               if (version >= 23)
+                       m_node_metadata.deSerialize(iss, m_gamedef->idef());
                else
                        content_nodemeta_deserialize_legacy(iss,
                else
                        content_nodemeta_deserialize_legacy(iss,
-                                       &m_node_metadata, &m_node_timers,
-                                       m_gamedef);
-       }
-       catch(SerializationError &e)
-       {
-               errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+                               &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;
        }
                                <<" while deserializing node metadata at ("
                                <<PP(getPos())<<": "<<e.what()<<std::endl;
        }
@@ -724,13 +721,13 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
                TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                                <<": Static objects"<<std::endl);
                m_static_objects.deSerialize(is);
                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;
                // 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);
                // Dynamically re-set ids based on node names
                TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                                <<": NameIdMapping"<<std::endl);
@@ -743,29 +740,40 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
                                        <<": Node timers (ver>=25)"<<std::endl);
                        m_node_timers.deSerialize(is, version);
                }
                                        <<": Node timers (ver>=25)"<<std::endl);
                        m_node_timers.deSerialize(is, version);
                }
-       } else {
-               if(version >= 26){
-                       heat = readF1000(is);
-                       humidity = readF1000(is);
-               }
        }
        }
-               
+
        TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
                        <<": Done."<<std::endl);
 }
 
        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)
+       {
+               warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+                               <<": "<<e.what()<<std::endl;
+       }
+}
+
 /*
        Legacy serialization
 */
 
 void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
 {
 /*
        Legacy serialization
 */
 
 void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
 {
-       u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
        // Initialize default flags
        is_underground = false;
        m_day_night_differs = false;
        // Initialize default flags
        is_underground = false;
        m_day_night_differs = false;
-       m_lighting_expired = false;
+       m_lighting_complete = 0xFFFF;
        m_generated = true;
 
        // Make a temporary buffer
        m_generated = true;
 
        // Make a temporary buffer
@@ -773,23 +781,20 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
        SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
 
        // These have no compression
        SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
 
        // These have no compression
-       if(version <= 3 || version == 5 || version == 6)
-       {
+       if (version <= 3 || version == 5 || version == 6) {
                char tmp;
                is.read(&tmp, 1);
                char tmp;
                is.read(&tmp, 1);
-               if(is.gcount() != 1)
-                       throw SerializationError
-                                       ("MapBlock::deSerialize: no enough input data");
+               if (is.gcount() != 1)
+                       throw SerializationError(std::string(FUNCTION_NAME)
+                               + ": not enough input data");
                is_underground = tmp;
                is_underground = tmp;
-               is.read((char*)*databuf_nodelist, nodecount * ser_length);
-               if((u32)is.gcount() != nodecount * ser_length)
-                       throw SerializationError
-                                       ("MapBlock::deSerialize: no enough input data");
-       }
-       else if(version <= 10)
-       {
+               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;
 
                {
@@ -797,11 +802,10 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                        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++)
-                       {
+                       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];
                        }
                }
                                databuf_nodelist[i*ser_length] = s[i];
                        }
                }
@@ -810,108 +814,91 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                        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++)
-                       {
+                       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];
                        }
                }
                                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++)
-                       {
+                       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];
                        }
                }
                                databuf_nodelist[i*ser_length + 2] = s[i];
                        }
                }
-       }
-       // All other versions (newest)
-       else
-       {
+       } 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");
+               if (s.size() != nodecount * 3)
+                       throw SerializationError(std::string(FUNCTION_NAME)
+                               + ": decompress resulted in size other than nodecount*3");
 
                // deserialize nodes from buffer
 
                // deserialize nodes from buffer
-               for(u32 i=0; i<nodecount; i++)
-               {
+               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];
                }
                        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);
                                        content_nodemeta_deserialize_legacy(iss,
                                        std::string data = deSerializeString(is);
                                        std::istringstream iss(data, std::ios_base::binary);
                                        content_nodemeta_deserialize_legacy(iss,
-                                                       &m_node_metadata, &m_node_timers,
-                                                       m_gamedef);
-                               }
-                               else
-                               {
+                                               &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);
                                        content_nodemeta_deserialize_legacy(iss,
                                        //std::string data = deSerializeLongString(is);
                                        std::ostringstream oss(std::ios_base::binary);
                                        decompressZlib(is, oss);
                                        std::istringstream iss(oss.str(), std::ios_base::binary);
                                        content_nodemeta_deserialize_legacy(iss,
-                                                       &m_node_metadata, &m_node_timers,
-                                                       m_gamedef);
+                                               &m_node_metadata, &m_node_timers,
+                                               m_gamedef->idef());
                                }
                                }
-                       }
-                       catch(SerializationError &e)
-                       {
-                               errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+                       } catch(SerializationError &e) {
+                               warningstream<<"MapBlock::deSerialize(): Ignoring an error"
                                                <<" while deserializing node metadata"<<std::endl;
                        }
                }
        }
 
        // Deserialize node data
                                                <<" while deserializing node metadata"<<std::endl;
                        }
                }
        }
 
        // Deserialize node data
-       for(u32 i=0; i<nodecount; i++)
-       {
-               data[i].deSerialize(&databuf_nodelist[i*ser_length], version);
+       for (u32 i = 0; i < nodecount; i++) {
+               data[i].deSerialize(&databuf_nodelist[i * ser_length], version);
        }
 
        }
 
-       if(disk)
-       {
+       if (disk) {
                /*
                        Versions up from 9 have block objects. (DEPRECATED)
                */
                /*
                        Versions up from 9 have block objects. (DEPRECATED)
                */
-               if(version >= 9){
+               if (version >= 9) {
                        u16 count = readU16(is);
                        // Not supported and length not known if count is not 0
                        if(count != 0){
                        u16 count = readU16(is);
                        // Not supported and length not known if count is not 0
                        if(count != 0){
-                               errorstream<<"WARNING: MapBlock::deSerialize_pre22(): "
+                               warningstream<<"MapBlock::deSerialize_pre22(): "
                                                <<"Ignoring stuff coming at and after MBOs"<<std::endl;
                                return;
                        }
                                                <<"Ignoring stuff coming at and after MBOs"<<std::endl;
                                return;
                        }
@@ -920,11 +907,11 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                /*
                        Versions up from 15 have static objects.
                */
                /*
                        Versions up from 15 have static objects.
                */
-               if(version >= 15)
+               if (version >= 15)
                        m_static_objects.deSerialize(is);
 
                // Timestamp
                        m_static_objects.deSerialize(is);
 
                // Timestamp
-               if(version >= 17){
+               if (version >= 17) {
                        setTimestamp(readU32(is));
                        m_disk_timestamp = m_timestamp;
                } else {
                        setTimestamp(readU32(is));
                        m_disk_timestamp = m_timestamp;
                } else {
@@ -934,7 +921,7 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                // Dynamically re-set ids based on node names
                NameIdMapping nimap;
                // If supported, read node definition id mapping
                // Dynamically re-set ids based on node names
                NameIdMapping nimap;
                // If supported, read node definition id mapping
-               if(version >= 21){
+               if (version >= 21) {
                        nimap.deSerialize(is);
                // Else set the legacy mapping
                } else {
                        nimap.deSerialize(is);
                // Else set the legacy mapping
                } else {
@@ -998,12 +985,12 @@ std::string analyze_block(MapBlock *block)
                return "NULL";
 
        std::ostringstream desc;
                return "NULL";
 
        std::ostringstream desc;
-       
+
        v3s16 p = block->getPos();
        v3s16 p = block->getPos();
-       char spos[20];
-       snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+       char spos[25];
+       snprintf(spos, sizeof(spos), "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
        desc<<spos;
        desc<<spos;
-       
+
        switch(block->getModified())
        {
        case MOD_STATE_CLEAN:
        switch(block->getModified())
        {
        case MOD_STATE_CLEAN:
@@ -1029,10 +1016,7 @@ std::string analyze_block(MapBlock *block)
        else
                desc<<"is_ug [ ], ";
 
        else
                desc<<"is_ug [ ], ";
 
-       if(block->getLightingExpired())
-               desc<<"lighting_exp [X], ";
-       else
-               desc<<"lighting_exp [ ], ";
+       desc<<"lighting_complete: "<<block->getLightingComplete()<<", ";
 
        if(block->isDummy())
        {
 
        if(block->isDummy())
        {
@@ -1049,7 +1033,7 @@ std::string analyze_block(MapBlock *block)
                for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
                {
                        v3s16 p(x0,y0,z0);
                for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
                {
                        v3s16 p(x0,y0,z0);
-                       MapNode n = block->getNode(p);
+                       MapNode n = block->getNodeNoEx(p);
                        content_t c = n.getContent();
                        if(c == CONTENT_IGNORE)
                                some_ignore = true;
                        content_t c = n.getContent();
                        if(c == CONTENT_IGNORE)
                                some_ignore = true;
@@ -1060,21 +1044,21 @@ std::string analyze_block(MapBlock *block)
                        else
                                full_air = false;
                }
                        else
                                full_air = false;
                }
-               
+
                desc<<"content {";
                desc<<"content {";
-               
+
                std::ostringstream ss;
                std::ostringstream ss;
-               
+
                if(full_ignore)
                        ss<<"IGNORE (full), ";
                else if(some_ignore)
                        ss<<"IGNORE, ";
                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(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);
 
                if(ss.str().size()>=2)
                        desc<<ss.str().substr(0, ss.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.