Clean up EmergeManager, do initial work on Mapgen configuration

[dragonfireclient.git] / src / mapnode.cpp

diff --git a/src/mapnode.cpp b/src/mapnode.cpp
index e12f252fcd269aa2df045d418dd5b6d6e7c8f24c..5dab93754a1e02d81d9a8722ae283502851f489b 100644 (file)
--- a/src/mapnode.cpp
+++ b/src/mapnode.cpp
@@ -39,11 +39,9 @@ MapNode::MapNode(INodeDefManager *ndef, const std::string &name,
 {
        content_t id = CONTENT_IGNORE;
        ndef->getId(name, id);
+       param0 = id;
        param1 = a_param1;
        param2 = a_param2;
-       // Set content (param0 and (param2&0xf0)) after other params
-       // because this needs to override part of param2
-       setContent(id);
 }
 
 void MapNode::setLight(enum LightBank bank, u8 a_light, INodeDefManager *nodemgr)
@@ -236,23 +234,25 @@ u32 MapNode::serializedLength(u8 version)
                return 1;
        else if(version <= 9)
                return 2;
-       else
+       else if(version <= 23)
                return 3;
+       else
+               return 4;
 }
 void MapNode::serialize(u8 *dest, u8 version)
 {
        if(!ser_ver_supported(version))
                throw VersionMismatchException("ERROR: MapNode format not supported");
-
-       if(version <= 21)
-       {
-               serialize_pre22(dest, version);
-               return;
-       }
-
-       writeU8(dest+0, param0);
-       writeU8(dest+1, param1);
-       writeU8(dest+2, param2);
+       
+       // 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("MapNode::serialize: serialization to "
+                               "version < 24 not possible");
+               
+       writeU16(dest+0, param0);
+       writeU8(dest+2, param1);
+       writeU8(dest+3, param2);
 }
 void MapNode::deSerialize(u8 *source, u8 version)
 {
@@ -265,9 +265,20 @@ void MapNode::deSerialize(u8 *source, u8 version)
                return;
        }
 
-       param0 = readU8(source+0);
-       param1 = readU8(source+1);
-       param2 = readU8(source+2);
+       if(version >= 24){
+               param0 = readU16(source+0);
+               param1 = readU8(source+2);
+               param2 = readU8(source+3);
+       }
+       else{
+               param0 = readU8(source+0);
+               param1 = readU8(source+1);
+               param2 = readU8(source+2);
+               if(param0 > 0x7F){
+                       param0 |= ((param2&0xF0)<<4);
+                       param2 &= 0x0F;
+               }
+       }
 }
 void MapNode::serializeBulk(std::ostream &os, int version,
                const MapNode *nodes, u32 nodecount,
@@ -276,24 +287,20 @@ void MapNode::serializeBulk(std::ostream &os, int version,
        if(!ser_ver_supported(version))
                throw VersionMismatchException("ERROR: MapNode format not supported");
 
-       assert(version >= 22);
-       assert(content_width == 1);
+       assert(content_width == 2);
        assert(params_width == 2);
 
+       // 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("MapNode::serializeBulk: serialization to "
+                               "version < 24 not possible");
+
        SharedBuffer<u8> databuf(nodecount * (content_width + params_width));
 
        // Serialize content
-       if(content_width == 1)
-       {
-               for(u32 i=0; i<nodecount; i++)
-                       writeU8(&databuf[i], nodes[i].param0);
-       }
-       /* If param0 is extended to two bytes, use something like this: */
-       /*else if(content_width == 2)
-       {
-               for(u32 i=0; i<nodecount; i++)
-                       writeU16(&databuf[i*2], nodes[i].param0);
-       }*/
+       for(u32 i=0; i<nodecount; i++)
+               writeU16(&databuf[i*2], nodes[i].param0);
 
        // Serialize param1
        u32 start1 = content_width * nodecount;
@@ -328,7 +335,7 @@ void MapNode::deSerializeBulk(std::istream &is, int version,
                throw VersionMismatchException("ERROR: MapNode format not supported");
 
        assert(version >= 22);
-       assert(content_width == 1);
+       assert(content_width == 1 || content_width == 2);
        assert(params_width == 2);
 
        // Uncompress or read data
@@ -358,12 +365,11 @@ void MapNode::deSerializeBulk(std::istream &is, int version,
                for(u32 i=0; i<nodecount; i++)
                        nodes[i].param0 = readU8(&databuf[i]);
        }
-       /* If param0 is extended to two bytes, use something like this: */
-       /*else if(content_width == 2)
+       else if(content_width == 2)
        {
                for(u32 i=0; i<nodecount; i++)
                        nodes[i].param0 = readU16(&databuf[i*2]);
-       }*/
+       }
 
        // Deserialize param1
        u32 start1 = content_width * nodecount;
@@ -372,47 +378,27 @@ void MapNode::deSerializeBulk(std::istream &is, int version,
 
        // Deserialize param2
        u32 start2 = (content_width + 1) * nodecount;
-       for(u32 i=0; i<nodecount; i++)
-               nodes[i].param2 = readU8(&databuf[start2 + i]);
-}
-
-/*
-       Legacy serialization
-*/
-void MapNode::serialize_pre22(u8 *dest, u8 version)
-{
-       // Translate to wanted version
-       MapNode n_foreign = mapnode_translate_from_internal(*this, version);
-
-       u8 actual_param0 = n_foreign.param0;
-
-       // Convert special values from new version to old
-       if(version <= 18)
-       {
-               // In these versions, CONTENT_IGNORE and CONTENT_AIR
-               // are 255 and 254
-               if(actual_param0 == CONTENT_IGNORE)
-                       actual_param0 = 255;
-               else if(actual_param0 == CONTENT_AIR)
-                       actual_param0 = 254;
-       }
-
-       if(version == 0)
-       {
-               dest[0] = actual_param0;
-       }
-       else if(version <= 9)
+       if(content_width == 1)
        {
-               dest[0] = actual_param0;
-               dest[1] = n_foreign.param1;
+               for(u32 i=0; i<nodecount; i++) {
+                       nodes[i].param2 = readU8(&databuf[start2 + i]);
+                       if(nodes[i].param0 > 0x7F){
+                               nodes[i].param0 <<= 4;
+                               nodes[i].param0 |= (nodes[i].param2&0xF0)>>4;
+                               nodes[i].param2 &= 0x0F;
+                       }
+               }
        }
-       else
+       else if(content_width == 2)
        {
-               dest[0] = actual_param0;
-               dest[1] = n_foreign.param1;
-               dest[2] = n_foreign.param2;
+               for(u32 i=0; i<nodecount; i++)
+                       nodes[i].param2 = readU8(&databuf[start2 + i]);
        }
 }
+
+/*
+       Legacy serialization
+*/
 void MapNode::deSerialize_pre22(u8 *source, u8 version)
 {
        if(version <= 1)
@@ -429,6 +415,11 @@ void MapNode::deSerialize_pre22(u8 *source, u8 version)
                param0 = source[0];
                param1 = source[1];
                param2 = source[2];
+               if(param0 > 0x7f){
+                       param0 <<= 4;
+                       param0 |= (param2&0xf0)>>4;
+                       param2 &= 0x0f;
+               }
        }
        
        // Convert special values from old version to new