]> 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
Tests: Modularize unit testing
[dragonfireclient.git] / src / mapblock.cpp
diff --git a/src/mapblock.cpp b/src/mapblock.cpp
index a6e9b3951f9d8103bbc53176d2f99d39b547e3d0..ca80c39d71cae6d55d9f2a49cccbdccdc2ebeb18 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,6 +29,7 @@ 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
 #ifndef SERVER
 #include "mapblock_mesh.h"
 #endif
@@ -63,9 +62,8 @@ MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
        data = NULL;
        if(dummy == false)
                reallocate();
        data = NULL;
        if(dummy == false)
                reallocate();
-       
+
 #ifndef SERVER
 #ifndef SERVER
-       //mesh_mutex.Init();
        mesh = NULL;
 #endif
 }
        mesh = NULL;
 #endif
 }
@@ -75,7 +73,7 @@ MapBlock::~MapBlock()
 #ifndef SERVER
        {
                //JMutexAutoLock lock(mesh_mutex);
 #ifndef SERVER
        {
                //JMutexAutoLock lock(mesh_mutex);
-               
+
                if(mesh)
                {
                        delete mesh;
                if(mesh)
                {
                        delete mesh;
@@ -99,60 +97,25 @@ bool MapBlock::isValidPositionParent(v3s16 p)
        }
 }
 
        }
 }
 
-MapNode MapBlock::getNodeParent(v3s16 p)
+MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position)
 {
 {
-       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];
-       }
-}
+       if (isValidPosition(p) == false)
+               return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position);
 
 
-void MapBlock::setNodeParent(v3s16 p, MapNode & n)
-{
-       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;
-       }
-}
-
-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];
+       if (data == NULL) {
+               if (is_valid_position)
+                       *is_valid_position = false;
+               return MapNode(CONTENT_IGNORE);
        }
        }
+       if (is_valid_position)
+               *is_valid_position = true;
+       return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X];
 }
 
 /*
        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.
@@ -168,26 +131,31 @@ MapNode MapBlock::getNodeParentNoEx(v3s16 p)
        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)
 {
        INodeDefManager *nodemgr = m_gamedef->ndef();
 
        // Whether the sunlight at the top of the bottom block is valid
        bool block_below_is_valid = true;
                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;
-       
+
        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
@@ -198,10 +166,10 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & 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)
@@ -210,7 +178,7 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                }
                                else
                                {
                                }
                                else
                                {
-                                       MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
+                                       MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z));
                                        if(m_gamedef->ndef()->get(n).sunlight_propagates == false)
                                        {
                                                no_sunlight = true;
                                        if(m_gamedef->ndef()->get(n).sunlight_propagates == false)
                                        {
                                                no_sunlight = true;
@@ -243,19 +211,19 @@ 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
@@ -268,7 +236,7 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                {
                                        // 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;
                                }
@@ -284,10 +252,10 @@ bool MapBlock::propagateSunlight(core::map<v3s16, bool> & light_sources,
                                {
                                        n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
                                }
                                {
                                        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)
@@ -307,30 +275,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(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 == 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;
+                                       }
+                               }
+                               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.
                        }
                }
        }
                        }
                }
        }
@@ -343,7 +311,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);
@@ -353,7 +321,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);
@@ -362,47 +330,42 @@ 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 == NULL) {
                m_day_night_differs = false;
                return;
        }
 
                m_day_night_differs = false;
                return;
        }
 
-       bool differs = false;
+       bool differs;
 
        /*
                Check if any lighting value differs
        */
 
        /*
                Check if any lighting value differs
        */
-       for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
-       {
+       for (u32 i = 0; i < MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++) {
                MapNode &n = data[i];
                MapNode &n = data[i];
-               if(n.getLight(LIGHTBANK_DAY, nodemgr) != n.getLight(LIGHTBANK_NIGHT, nodemgr))
-               {
-                       differs = true;
+
+               differs = !n.isLightDayNightEq(nodemgr);
+               if (differs)
                        break;
                        break;
-               }
        }
 
        /*
                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 < MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; 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;
        }
 
@@ -454,10 +417,16 @@ 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];
 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 * sizeof(content_t));
+
        std::set<content_t> unknown_contents;
        content_t id_counter = 0;
        for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
        std::set<content_t> unknown_contents;
        content_t id_counter = 0;
        for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
@@ -466,16 +435,14 @@ static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
                content_t id = CONTENT_IGNORE;
 
                // Try to find an existing mapping
                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;
@@ -548,18 +515,14 @@ 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)
        {
                throw SerializationError("ERROR: Not writing dummy block.");
        }
        if(data == NULL)
        {
                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_CLIENT_VER_LOWEST, "Serialize version error");
+
        // First byte
        u8 flags = 0;
        if(is_underground)
        // First byte
        u8 flags = 0;
        if(is_underground)
@@ -571,7 +534,7 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
        if(m_generated == false)
                flags |= 0x08;
        writeU8(os, flags);
        if(m_generated == false)
                flags |= 0x08;
        writeU8(os, flags);
-       
+
        /*
                Bulk node data
        */
        /*
                Bulk node data
        */
@@ -601,7 +564,7 @@ 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
        */
        /*
                Node metadata
        */
@@ -627,7 +590,7 @@ 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);
@@ -635,11 +598,26 @@ void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
        }
 }
 
        }
 }
 
+void MapBlock::serializeNetworkSpecific(std::ostream &os, u16 net_proto_version)
+{
+       if(data == NULL)
+       {
+               throw SerializationError("ERROR: Not writing dummy block.");
+       }
+
+       if(net_proto_version >= 21){
+               int version = 1;
+               writeU8(os, 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;
@@ -715,13 +693,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);
@@ -735,11 +713,29 @@ void MapBlock::deSerialize(std::istream &is, u8 version, bool disk)
                        m_node_timers.deSerialize(is, version);
                }
        }
                        m_node_timers.deSerialize(is, version);
                }
        }
-               
+
        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)
+       {
+               errorstream<<"WARNING: MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+                               <<": "<<e.what()<<std::endl;
+       }
+}
+
 /*
        Legacy serialization
 */
 /*
        Legacy serialization
 */
@@ -804,7 +800,7 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                                databuf_nodelist[i*ser_length + 1] = s[i];
                        }
                }
                                databuf_nodelist[i*ser_length + 1] = s[i];
                        }
                }
-       
+
                if(version >= 10)
                {
                        // Uncompress and set param2 data
                if(version >= 10)
                {
                        // Uncompress and set param2 data
@@ -847,7 +843,7 @@ void MapBlock::deSerialize_pre22(std::istream &is, u8 version, bool disk)
                        databuf_nodelist[i*ser_length + 1] = s[i+nodecount];
                        databuf_nodelist[i*ser_length + 2] = s[i+nodecount*2];
                }
                        databuf_nodelist[i*ser_length + 1] = s[i+nodecount];
                        databuf_nodelist[i*ser_length + 2] = s[i+nodecount*2];
                }
-               
+
                /*
                        NodeMetadata
                */
                /*
                        NodeMetadata
                */
@@ -984,12 +980,12 @@ std::string analyze_block(MapBlock *block)
                return "NULL";
 
        std::ostringstream desc;
                return "NULL";
 
        std::ostringstream desc;
-       
+
        v3s16 p = block->getPos();
        char spos[20];
        snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
        desc<<spos;
        v3s16 p = block->getPos();
        char spos[20];
        snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
        desc<<spos;
-       
+
        switch(block->getModified())
        {
        case MOD_STATE_CLEAN:
        switch(block->getModified())
        {
        case MOD_STATE_CLEAN:
@@ -1035,7 +1031,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;
@@ -1046,21 +1042,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.