/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "mapblock.h"
+
+#include <sstream>
#include "map.h"
-// For g_settings
-#include "main.h"
#include "light.h"
-#include <sstream>
+#include "nodedef.h"
+#include "nodemetadata.h"
+#include "gamedef.h"
+#include "log.h"
+#include "nameidmapping.h"
+#include "content_mapnode.h" // For legacy name-id mapping
+#include "content_nodemeta.h" // For legacy deserialization
+#include "serialization.h"
+#ifndef SERVER
+#include "mapblock_mesh.h"
+#endif
+#include "util/string.h"
+#include "util/serialize.h"
+
+#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
/*
MapBlock
*/
-MapBlock::MapBlock(Map *parent, v3s16 pos, bool dummy):
+MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
+ heat(0),
+ humidity(0),
+ heat_last_update(0),
+ humidity_last_update(0),
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_objects(this),
m_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
- m_usage_timer(0)
+ m_disk_timestamp(BLOCK_TIMESTAMP_UNDEFINED),
+ m_usage_timer(0),
+ m_refcount(0)
{
data = NULL;
if(dummy == false)
reallocate();
- //m_spawn_timer = -10000;
-
#ifndef SERVER
- m_mesh_expired = false;
- mesh_mutex.Init();
+ //mesh_mutex.Init();
mesh = NULL;
- m_temp_mods_mutex.Init();
#endif
}
{
#ifndef SERVER
{
- JMutexAutoLock lock(mesh_mutex);
+ //JMutexAutoLock lock(mesh_mutex);
if(mesh)
{
- mesh->drop();
+ delete mesh;
mesh = NULL;
}
}
}
}
-#ifndef SERVER
-
-#if 1
-void MapBlock::updateMesh(u32 daynight_ratio)
-{
-#if 0
- /*
- DEBUG: If mesh has been generated, don't generate it again
- */
- {
- JMutexAutoLock meshlock(mesh_mutex);
- if(mesh != NULL)
- return;
- }
-#endif
-
- MeshMakeData data;
- data.fill(daynight_ratio, this);
-
- scene::SMesh *mesh_new = makeMapBlockMesh(&data);
-
- /*
- Replace the mesh
- */
-
- replaceMesh(mesh_new);
-
-}
-#endif
-
-void MapBlock::replaceMesh(scene::SMesh *mesh_new)
-{
- mesh_mutex.Lock();
-
- //scene::SMesh *mesh_old = mesh[daynight_i];
- //mesh[daynight_i] = mesh_new;
-
- scene::SMesh *mesh_old = mesh;
- mesh = mesh_new;
- setMeshExpired(false);
-
- if(mesh_old != NULL)
- {
- // Remove hardware buffers of meshbuffers of mesh
- // NOTE: No way, this runs in a different thread and everything
- /*u32 c = mesh_old->getMeshBufferCount();
- for(u32 i=0; i<c; i++)
- {
- IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
- }*/
-
- /*dstream<<"mesh_old->getReferenceCount()="
- <<mesh_old->getReferenceCount()<<std::endl;
- u32 c = mesh_old->getMeshBufferCount();
- for(u32 i=0; i<c; i++)
- {
- scene::IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
- dstream<<"buf->getReferenceCount()="
- <<buf->getReferenceCount()<<std::endl;
- }*/
-
- // Drop the mesh
- mesh_old->drop();
-
- //delete mesh_old;
- }
-
- mesh_mutex.Unlock();
-}
-
-#endif // !SERVER
-
/*
Propagates sunlight down through the block.
Doesn't modify nodes that are not affected by sunlight.
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;
// Trust heuristics
no_sunlight = is_underground;
}
- else if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
+ else if(n.getLight(LIGHTBANK_DAY, m_gamedef->ndef()) != LIGHT_SUN)
{
no_sunlight = true;
}
else
{
MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z));
- //if(n.getContent() == CONTENT_WATER || n.getContent() == CONTENT_WATERSOURCE)
- if(content_features(n).sunlight_propagates == false)
+ if(m_gamedef->ndef()->get(n).sunlight_propagates == false)
{
no_sunlight = true;
}
{
// Do nothing
}
- else if(current_light == LIGHT_SUN && n.sunlight_propagates())
+ else if(current_light == LIGHT_SUN && nodemgr->get(n).sunlight_propagates)
{
// Do nothing: Sunlight is continued
}
- else if(n.light_propagates() == false)
+ else if(nodemgr->get(n).light_propagates == false)
{
- /*// DEPRECATED TODO: REMOVE
- if(grow_grass)
- {
- bool upper_is_air = false;
- try
- {
- if(getNodeParent(pos+v3s16(0,1,0)).getContent() == CONTENT_AIR)
- upper_is_air = true;
- }
- catch(InvalidPositionException &e)
- {
- }
- // Turn mud into grass
- if(upper_is_air && n.getContent() == CONTENT_MUD
- && current_light == LIGHT_SUN)
- {
- n.d = CONTENT_GRASS;
- }
- }*/
-
// A solid object is on the way.
stopped_to_solid_object = true;
current_light = diminish_light(current_light);
}
- u8 old_light = n.getLight(LIGHTBANK_DAY);
+ u8 old_light = n.getLight(LIGHTBANK_DAY, nodemgr);
if(current_light > old_light || remove_light)
{
- n.setLight(LIGHTBANK_DAY, current_light);
+ n.setLight(LIGHTBANK_DAY, current_light, nodemgr);
}
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(block_below_is_valid)
{
MapNode n = getNodeParent(v3s16(x, -1, z));
- if(n.light_propagates())
+ if(nodemgr->get(n).light_propagates)
{
- if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN
+ if(n.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN
&& sunlight_should_go_down == false)
block_below_is_valid = false;
- else if(n.getLight(LIGHTBANK_DAY) != LIGHT_SUN
+ else if(n.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN
&& sunlight_should_go_down == true)
block_below_is_valid = false;
}
getPosRelative(), data_size);
}
-void MapBlock::stepObjects(float dtime, bool server, u32 daynight_ratio)
+void MapBlock::actuallyUpdateDayNightDiff()
{
- /*
- Step objects
- */
- m_objects.step(dtime, server, daynight_ratio);
+ INodeDefManager *nodemgr = m_gamedef->ndef();
+ // Running this function un-expires m_day_night_differs
+ m_day_night_differs_expired = false;
- setChangedFlag();
-}
-
-
-void MapBlock::updateDayNightDiff()
-{
if(data == NULL)
{
m_day_night_differs = false;
for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
{
MapNode &n = data[i];
- if(n.getLight(LIGHTBANK_DAY) != n.getLight(LIGHTBANK_NIGHT))
+ if(n.getLight(LIGHTBANK_DAY, nodemgr) != n.getLight(LIGHTBANK_NIGHT, nodemgr))
{
differs = true;
break;
m_day_night_differs = differs;
}
+void MapBlock::expireDayNightDiff()
+{
+ //INodeDefManager *nodemgr = m_gamedef->ndef();
+
+ if(data == NULL){
+ m_day_night_differs = false;
+ m_day_night_differs_expired = false;
+ return;
+ }
+
+ m_day_night_differs_expired = true;
+}
+
s16 MapBlock::getGroundLevel(v2s16 p2d)
{
if(isDummy())
for(; y>=0; y--)
{
MapNode n = getNodeRef(p2d.X, y, p2d.Y);
- if(content_features(n).walkable)
+ if(m_gamedef->ndef()->get(n).walkable)
{
if(y == MAP_BLOCKSIZE-1)
return -2;
/*
Serialization
*/
+// List relevant id-name pairs for ids in the block using nodedef
+// Renumbers the content IDs (starting at 0 and incrementing
+static void getBlockNodeIdMapping(NameIdMapping *nimap, MapNode *nodes,
+ INodeDefManager *nodedef)
+{
+ std::map<content_t, content_t> mapping;
+ std::set<content_t> unknown_contents;
+ content_t id_counter = 0;
+ for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
+ {
+ 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;
+ }
+ else
+ {
+ // We have to assign a new mapping
+ id = id_counter++;
+ mapping.insert(std::make_pair(global_id, id));
+
+ const ContentFeatures &f = nodedef->get(global_id);
+ const std::string &name = f.name;
+ if(name == "")
+ unknown_contents.insert(global_id);
+ else
+ nimap->set(id, name);
+ }
-void MapBlock::serialize(std::ostream &os, u8 version)
+ // 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;
+ }
+}
+// Correct ids in the block to match nodedef based on names.
+// Unknown ones are added to nodedef.
+// Will not update itself to match id-name pairs in nodedef.
+static void correctBlockNodeIds(const NameIdMapping *nimap, MapNode *nodes,
+ IGameDef *gamedef)
+{
+ INodeDefManager *nodedef = gamedef->ndef();
+ // This means the block contains incorrect ids, and we contain
+ // the information to convert those to names.
+ // nodedef contains information to convert our names to globally
+ // correct ids.
+ std::set<content_t> unnamed_contents;
+ std::set<std::string> unallocatable_contents;
+ for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
+ {
+ content_t local_id = nodes[i].getContent();
+ std::string name;
+ bool found = nimap->getName(local_id, name);
+ if(!found){
+ unnamed_contents.insert(local_id);
+ continue;
+ }
+ content_t global_id;
+ found = nodedef->getId(name, global_id);
+ if(!found){
+ global_id = gamedef->allocateUnknownNodeId(name);
+ if(global_id == CONTENT_IGNORE){
+ unallocatable_contents.insert(name);
+ continue;
+ }
+ }
+ nodes[i].setContent(global_id);
+ }
+ 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(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;
+ }
+}
+
+void MapBlock::serialize(std::ostream &os, u8 version, bool disk)
{
if(!ser_ver_supported(version))
throw VersionMismatchException("ERROR: MapBlock format not supported");
throw SerializationError("ERROR: Not writing dummy block.");
}
- // These have no compression
- if(version <= 3 || version == 5 || version == 6)
- {
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
- u32 buflen = 1 + nodecount * MapNode::serializedLength(version);
- SharedBuffer<u8> dest(buflen);
-
- dest[0] = is_underground;
- for(u32 i=0; i<nodecount; i++)
- {
- u32 s = 1 + i * MapNode::serializedLength(version);
- data[i].serialize(&dest[s], version);
- }
+ // 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");
- os.write((char*)*dest, dest.getSize());
- }
- else if(version <= 10)
+ // First byte
+ u8 flags = 0;
+ if(is_underground)
+ flags |= 0x01;
+ if(getDayNightDiff())
+ flags |= 0x02;
+ if(m_lighting_expired)
+ flags |= 0x04;
+ if(m_generated == false)
+ flags |= 0x08;
+ writeU8(os, flags);
+
+ /*
+ Bulk node data
+ */
+ NameIdMapping nimap;
+ u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ if(disk)
{
- /*
- With compression.
- Compress the materials and the params separately.
- */
-
- // First byte
- os.write((char*)&is_underground, 1);
-
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
- // Get and compress materials
- SharedBuffer<u8> materialdata(nodecount);
+ MapNode *tmp_nodes = new MapNode[nodecount];
for(u32 i=0; i<nodecount; i++)
- {
- materialdata[i] = data[i].param0;
- }
- compress(materialdata, os, version);
-
- // Get and compress lights
- SharedBuffer<u8> lightdata(nodecount);
- for(u32 i=0; i<nodecount; i++)
- {
- lightdata[i] = data[i].param1;
- }
- compress(lightdata, os, version);
-
- if(version >= 10)
- {
- // Get and compress param2
- SharedBuffer<u8> param2data(nodecount);
- for(u32 i=0; i<nodecount; i++)
- {
- param2data[i] = data[i].param2;
- }
- compress(param2data, os, version);
- }
+ tmp_nodes[i] = data[i];
+ getBlockNodeIdMapping(&nimap, tmp_nodes, m_gamedef->ndef());
+
+ u8 content_width = 2;
+ u8 params_width = 2;
+ writeU8(os, content_width);
+ writeU8(os, params_width);
+ MapNode::serializeBulk(os, version, tmp_nodes, nodecount,
+ content_width, params_width, true);
+ delete[] tmp_nodes;
}
- // All other versions (newest)
else
{
- // First byte
- u8 flags = 0;
- if(is_underground)
- flags |= 0x01;
- if(m_day_night_differs)
- flags |= 0x02;
- if(m_lighting_expired)
- flags |= 0x04;
- if(version >= 18)
- {
- if(m_generated == false)
- flags |= 0x08;
+ u8 content_width = 2;
+ u8 params_width = 2;
+ writeU8(os, content_width);
+ writeU8(os, params_width);
+ MapNode::serializeBulk(os, version, data, nodecount,
+ content_width, params_width, true);
+ }
+
+ /*
+ Node metadata
+ */
+ std::ostringstream oss(std::ios_base::binary);
+ m_node_metadata.serialize(oss);
+ compressZlib(oss.str(), os);
+
+ /*
+ Data that goes to disk, but not the network
+ */
+ if(disk)
+ {
+ if(version <= 24){
+ // Node timers
+ m_node_timers.serialize(os, version);
}
- os.write((char*)&flags, 1);
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
+ // Static objects
+ m_static_objects.serialize(os);
- /*
- Get data
- */
+ // Timestamp
+ writeU32(os, getTimestamp());
- // Serialize nodes
- SharedBuffer<u8> databuf_nodelist(nodecount*3);
- for(u32 i=0; i<nodecount; i++)
- {
- data[i].serialize(&databuf_nodelist[i*3], version);
- }
+ // Write block-specific node definition id mapping
+ nimap.serialize(os);
- // Create buffer with different parameters sorted
- SharedBuffer<u8> databuf(nodecount*3);
- for(u32 i=0; i<nodecount; i++)
- {
- databuf[i] = databuf_nodelist[i*3];
- databuf[i+nodecount] = databuf_nodelist[i*3+1];
- databuf[i+nodecount*2] = databuf_nodelist[i*3+2];
+ if(version >= 25){
+ // Node timers
+ m_node_timers.serialize(os, version);
}
+ }
+}
- /*
- Compress data to output stream
- */
+void MapBlock::serializeNetworkSpecific(std::ostream &os, u16 net_proto_version)
+{
+ if(data == NULL)
+ {
+ throw SerializationError("ERROR: Not writing dummy block.");
+ }
- compress(databuf, os, version);
-
- /*
- NodeMetadata
- */
- if(version >= 14)
- {
- if(version <= 15)
- {
- try{
- std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
- os<<serializeString(oss.str());
- }
- // This will happen if the string is longer than 65535
- catch(SerializationError &e)
- {
- // Use an empty string
- os<<serializeString("");
- }
- }
- else
- {
- std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
- compressZlib(oss.str(), os);
- //os<<serializeLongString(oss.str());
- }
- }
+ if(net_proto_version >= 21){
+ int version = 1;
+ writeU8(os, version);
+ writeF1000(os, heat);
+ writeF1000(os, humidity);
}
}
-void MapBlock::deSerialize(std::istream &is, u8 version)
+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;
+
+ if(version <= 21)
+ {
+ deSerialize_pre22(is, version, disk);
+ return;
+ }
+
+ 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;
+
+ /*
+ 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)
+ throw SerializationError("MapBlock::deSerialize(): invalid content_width");
+ if(params_width != 2)
+ throw SerializationError("MapBlock::deSerialize(): invalid params_width");
+ MapNode::deSerializeBulk(is, version, data, nodecount,
+ content_width, params_width, true);
- // These have no lighting info
- if(version <= 1)
+ /*
+ NodeMetadata
+ */
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node metadata"<<std::endl);
+ // Ignore errors
+ try{
+ std::ostringstream oss(std::ios_base::binary);
+ decompressZlib(is, oss);
+ std::istringstream iss(oss.str(), std::ios_base::binary);
+ if(version >= 23)
+ m_node_metadata.deSerialize(iss, m_gamedef);
+ else
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
+ }
+ catch(SerializationError &e)
{
- setLightingExpired(true);
+ errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+ <<" while deserializing node metadata at ("
+ <<PP(getPos())<<": "<<e.what()<<std::endl;
}
- // These have no "generated" field
- if(version < 18)
+ /*
+ Data that is only on disk
+ */
+ if(disk)
{
- m_generated = true;
+ // Node timers
+ if(version == 23){
+ // Read unused zero
+ readU8(is);
+ }
+ if(version == 24){
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node timers (ver==24)"<<std::endl);
+ m_node_timers.deSerialize(is, version);
+ }
+
+ // Static objects
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Static objects"<<std::endl);
+ m_static_objects.deSerialize(is);
+
+ // Timestamp
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Timestamp"<<std::endl);
+ setTimestamp(readU32(is));
+ m_disk_timestamp = m_timestamp;
+
+ // Dynamically re-set ids based on node names
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": NameIdMapping"<<std::endl);
+ NameIdMapping nimap;
+ nimap.deSerialize(is);
+ correctBlockNodeIds(&nimap, data, m_gamedef);
+
+ if(version >= 25){
+ TRACESTREAM(<<"MapBlock::deSerialize "<<PP(getPos())
+ <<": Node timers (ver>=25)"<<std::endl);
+ m_node_timers.deSerialize(is, version);
+ }
}
+
+ 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) {
+ heat = readF1000(is);
+ humidity = readF1000(is);
+ }
+ }
+ catch(SerializationError &e)
+ {
+ errorstream<<"WARNING: MapBlock::deSerializeNetworkSpecific(): Ignoring an error"
+ <<": "<<e.what()<<std::endl;
+ }
+}
+
+/*
+ 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;
+ m_lighting_expired = false;
+ m_generated = true;
+
+ // Make a temporary buffer
+ u32 ser_length = MapNode::serializedLength(version);
+ SharedBuffer<u8> databuf_nodelist(nodecount * ser_length);
// These have no compression
if(version <= 3 || version == 5 || version == 6)
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
char tmp;
is.read(&tmp, 1);
if(is.gcount() != 1)
throw SerializationError
("MapBlock::deSerialize: no enough input data");
is_underground = tmp;
- for(u32 i=0; i<nodecount; i++)
- {
- s32 len = MapNode::serializedLength(version);
- SharedBuffer<u8> d(len);
- is.read((char*)*d, len);
- if(is.gcount() != len)
- throw SerializationError
- ("MapBlock::deSerialize: no enough input data");
- data[i].deSerialize(*d, version);
- }
+ 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)
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
u8 t8;
is.read((char*)&t8, 1);
is_underground = t8;
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param0 = s[i];
+ databuf_nodelist[i*ser_length] = s[i];
}
}
{
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param1 = s[i];
+ databuf_nodelist[i*ser_length + 1] = s[i];
}
}
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param2 = s[i];
+ databuf_nodelist[i*ser_length + 2] = s[i];
}
}
}
// All other versions (newest)
else
{
- u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
-
u8 flags;
is.read((char*)&flags, 1);
is_underground = (flags & 0x01) ? true : false;
// deserialize nodes from buffer
for(u32 i=0; i<nodecount; i++)
{
- u8 buf[3];
- buf[0] = s[i];
- buf[1] = s[i+nodecount];
- buf[2] = s[i+nodecount*2];
- data[i].deSerialize(buf, version);
+ 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];
}
/*
{
std::string data = deSerializeString(is);
std::istringstream iss(data, std::ios_base::binary);
- m_node_metadata.deSerialize(iss);
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
}
else
{
std::ostringstream oss(std::ios_base::binary);
decompressZlib(is, oss);
std::istringstream iss(oss.str(), std::ios_base::binary);
- m_node_metadata.deSerialize(iss);
+ content_nodemeta_deserialize_legacy(iss,
+ &m_node_metadata, &m_node_timers,
+ m_gamedef);
}
}
catch(SerializationError &e)
{
- dstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
+ errorstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error"
<<" while deserializing node metadata"<<std::endl;
}
}
}
-}
-void MapBlock::serializeDiskExtra(std::ostream &os, u8 version)
-{
- // Versions up from 9 have block objects.
- if(version >= 9)
+ // Deserialize node data
+ for(u32 i=0; i<nodecount; i++)
{
- //serializeObjects(os, version); // DEPRECATED
- // count=0
- writeU16(os, 0);
+ data[i].deSerialize(&databuf_nodelist[i*ser_length], version);
}
-
- // Versions up from 15 have static objects.
- if(version >= 15)
+
+ if(disk)
{
- m_static_objects.serialize(os);
+ /*
+ Versions up from 9 have block objects. (DEPRECATED)
+ */
+ if(version >= 9){
+ u16 count = readU16(is);
+ // Not supported and length not known if count is not 0
+ if(count != 0){
+ errorstream<<"WARNING: MapBlock::deSerialize_pre22(): "
+ <<"Ignoring stuff coming at and after MBOs"<<std::endl;
+ return;
+ }
+ }
+
+ /*
+ Versions up from 15 have static objects.
+ */
+ if(version >= 15)
+ m_static_objects.deSerialize(is);
+
+ // Timestamp
+ if(version >= 17){
+ setTimestamp(readU32(is));
+ m_disk_timestamp = m_timestamp;
+ } else {
+ setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+ }
+
+ // Dynamically re-set ids based on node names
+ NameIdMapping nimap;
+ // If supported, read node definition id mapping
+ if(version >= 21){
+ nimap.deSerialize(is);
+ // Else set the legacy mapping
+ } else {
+ content_mapnode_get_name_id_mapping(&nimap);
+ }
+ correctBlockNodeIds(&nimap, data, m_gamedef);
}
- // Timestamp
- if(version >= 17)
+
+ // Legacy data changes
+ // This code has to convert from pre-22 to post-22 format.
+ INodeDefManager *nodedef = m_gamedef->ndef();
+ for(u32 i=0; i<nodecount; i++)
{
- writeU32(os, getTimestamp());
+ const ContentFeatures &f = nodedef->get(data[i].getContent());
+ // Mineral
+ if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 1)
+ {
+ data[i].setContent(nodedef->getId("default:stone_with_coal"));
+ data[i].setParam1(0);
+ }
+ else if(nodedef->getId("default:stone") == data[i].getContent()
+ && data[i].getParam1() == 2)
+ {
+ data[i].setContent(nodedef->getId("default:stone_with_iron"));
+ data[i].setParam1(0);
+ }
+ // facedir_simple
+ if(f.legacy_facedir_simple)
+ {
+ data[i].setParam2(data[i].getParam1());
+ data[i].setParam1(0);
+ }
+ // wall_mounted
+ if(f.legacy_wallmounted)
+ {
+ u8 wallmounted_new_to_old[8] = {0x04, 0x08, 0x01, 0x02, 0x10, 0x20, 0, 0};
+ u8 dir_old_format = data[i].getParam2();
+ u8 dir_new_format = 0;
+ for(u8 j=0; j<8; j++)
+ {
+ if((dir_old_format & wallmounted_new_to_old[j]) != 0)
+ {
+ dir_new_format = j;
+ break;
+ }
+ }
+ data[i].setParam2(dir_new_format);
+ }
}
+
}
-void MapBlock::deSerializeDiskExtra(std::istream &is, u8 version)
+/*
+ Get a quick string to describe what a block actually contains
+*/
+std::string analyze_block(MapBlock *block)
{
- /*
- Versions up from 9 have block objects.
- */
- if(version >= 9)
- {
- updateObjects(is, version, NULL, 0);
- }
+ if(block == NULL)
+ return "NULL";
- /*
- Versions up from 15 have static objects.
- */
- if(version >= 15)
+ std::ostringstream desc;
+
+ v3s16 p = block->getPos();
+ char spos[20];
+ snprintf(spos, 20, "(%2d,%2d,%2d), ", p.X, p.Y, p.Z);
+ desc<<spos;
+
+ switch(block->getModified())
{
- m_static_objects.deSerialize(is);
+ case MOD_STATE_CLEAN:
+ desc<<"CLEAN, ";
+ break;
+ case MOD_STATE_WRITE_AT_UNLOAD:
+ desc<<"WRITE_AT_UNLOAD, ";
+ break;
+ case MOD_STATE_WRITE_NEEDED:
+ desc<<"WRITE_NEEDED, ";
+ break;
+ default:
+ desc<<"unknown getModified()="+itos(block->getModified())+", ";
}
-
- // Timestamp
- if(version >= 17)
+
+ if(block->isGenerated())
+ desc<<"is_gen [X], ";
+ else
+ desc<<"is_gen [ ], ";
+
+ if(block->getIsUnderground())
+ desc<<"is_ug [X], ";
+ else
+ desc<<"is_ug [ ], ";
+
+ if(block->getLightingExpired())
+ desc<<"lighting_exp [X], ";
+ else
+ desc<<"lighting_exp [ ], ";
+
+ if(block->isDummy())
{
- setTimestamp(readU32(is));
+ desc<<"Dummy, ";
}
else
{
- setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+ bool full_ignore = true;
+ bool some_ignore = false;
+ bool full_air = true;
+ bool some_air = false;
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+ {
+ v3s16 p(x0,y0,z0);
+ MapNode n = block->getNode(p);
+ content_t c = n.getContent();
+ if(c == CONTENT_IGNORE)
+ some_ignore = true;
+ else
+ full_ignore = false;
+ if(c == CONTENT_AIR)
+ some_air = true;
+ else
+ full_air = false;
+ }
+
+ desc<<"content {";
+
+ std::ostringstream ss;
+
+ if(full_ignore)
+ ss<<"IGNORE (full), ";
+ else if(some_ignore)
+ ss<<"IGNORE, ";
+
+ if(full_air)
+ ss<<"AIR (full), ";
+ else if(some_air)
+ ss<<"AIR, ";
+
+ if(ss.str().size()>=2)
+ desc<<ss.str().substr(0, ss.str().size()-2);
+
+ desc<<"}, ";
}
+
+ return desc.str().substr(0, desc.str().size()-2);
}