X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmapblock.cpp;h=840cb9b3994a28da789db0f898433e8da1cc49dd;hb=ab371cc93491baf0973ecc94b96c3a1fdb4abfd5;hp=7500143c037b5e5d35162f182f52e7893f378e3d;hpb=2b9d03b267a3a11e6fc81d94423caaa852616fa8;p=oweals%2Fminetest.git diff --git a/src/mapblock.cpp b/src/mapblock.cpp index 7500143c0..840cb9b39 100644 --- a/src/mapblock.cpp +++ b/src/mapblock.cpp @@ -1,770 +1,348 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola 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 #include "map.h" -// For g_materials -#include "main.h" #include "light.h" -#include +#include "nodedef.h" +#include "nodemetadata.h" +#include "gamedef.h" +#include "log.h" +#include "nameidmapping.h" +#include "content_mapnode.h" // For legacy name-id mapping +#include "content_nodemeta.h" // For legacy deserialization +#include "serialization.h" +#ifndef SERVER +#include "mapblock_mesh.h" +#endif +#include "util/string.h" +#include "util/serialize.h" +#include "util/basic_macros.h" + +static const char *modified_reason_strings[] = { + "initial", + "reallocate", + "setIsUnderground", + "setLightingExpired", + "setGenerated", + "setNode", + "setNodeNoCheck", + "setTimestamp", + "NodeMetaRef::reportMetadataChange", + "clearAllObjects", + "Timestamp expired (step)", + "addActiveObjectRaw", + "removeRemovedObjects/remove", + "removeRemovedObjects/deactivate", + "Stored list cleared in activateObjects due to overflow", + "deactivateFarObjects: Static data moved in", + "deactivateFarObjects: Static data moved out", + "deactivateFarObjects: Static data changed considerably", + "finishBlockMake: expireDayNightDiff", + "unknown", +}; /* MapBlock */ -bool MapBlock::isValidPositionParent(v3s16 p) +MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy): + m_parent(parent), + m_pos(pos), + m_pos_relative(pos * MAP_BLOCKSIZE), + m_gamedef(gamedef), + m_modified(MOD_STATE_WRITE_NEEDED), + m_modified_reason(MOD_REASON_INITIAL), + is_underground(false), + m_lighting_complete(0xFFFF), + 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) { - if(isValidPosition(p)) - { - return true; - } - else{ - return m_parent->isValidPosition(getPosRelative() + p); - } -} + data = NULL; + if(dummy == false) + reallocate(); -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]; - } +#ifndef SERVER + mesh = NULL; +#endif } -void MapBlock::setNodeParent(v3s16 p, MapNode & n) +MapBlock::~MapBlock() { - if(isValidPosition(p) == false) +#ifndef SERVER { - 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; + //MutexAutoLock lock(mesh_mutex); + + if(mesh) + { + delete mesh; + mesh = NULL; + } } -} +#endif -FastFace * MapBlock::makeFastFace(u8 material, u8 light, v3f p, - v3f dir, v3f scale, v3f posRelative_f) -{ - FastFace *f = new FastFace; - - // Position is at the center of the cube. - v3f pos = p * BS; - posRelative_f *= BS; - - v3f vertex_pos[4]; - // If looking towards z+, this is the face that is behind - // the center point, facing towards z+. - vertex_pos[0] = v3f( BS/2,-BS/2,BS/2); - vertex_pos[1] = v3f(-BS/2,-BS/2,BS/2); - vertex_pos[2] = v3f(-BS/2, BS/2,BS/2); - vertex_pos[3] = v3f( BS/2, BS/2,BS/2); - - /* - TODO: Rotate it the right way (one side comes upside down) - */ - core::CMatrix4 m; - m.buildRotateFromTo(v3f(0,0,1), dir); - - for(u16 i=0; i<4; i++){ - m.rotateVect(vertex_pos[i]); - vertex_pos[i].X *= scale.X; - vertex_pos[i].Y *= scale.Y; - vertex_pos[i].Z *= scale.Z; - vertex_pos[i] += pos + posRelative_f; - } - - f32 abs_scale = 1.; - if (scale.X < 0.999 || scale.X > 1.001) abs_scale = scale.X; - else if(scale.Y < 0.999 || scale.Y > 1.001) abs_scale = scale.Y; - else if(scale.Z < 0.999 || scale.Z > 1.001) abs_scale = scale.Z; - - v3f zerovector = v3f(0,0,0); - - u8 li = decode_light(light); - //u8 li = 150; - - u8 alpha = 255; - - if(material == CONTENT_WATER || material == CONTENT_OCEAN) - { - alpha = 128; - } - - video::SColor c = video::SColor(alpha,li,li,li); - - /*f->vertices[0] = video::S3DVertex(vertex_pos[0], zerovector, c, - core::vector2d(0,1)); - f->vertices[1] = video::S3DVertex(vertex_pos[1], zerovector, c, - core::vector2d(abs_scale,1)); - f->vertices[2] = video::S3DVertex(vertex_pos[2], zerovector, c, - core::vector2d(abs_scale,0)); - f->vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c, - core::vector2d(0,0));*/ - f->vertices[0] = video::S3DVertex(vertex_pos[0], zerovector, c, - core::vector2d(0,1)); - f->vertices[1] = video::S3DVertex(vertex_pos[1], zerovector, c, - core::vector2d(abs_scale,1)); - f->vertices[2] = video::S3DVertex(vertex_pos[2], zerovector, c, - core::vector2d(abs_scale,0)); - f->vertices[3] = video::S3DVertex(vertex_pos[3], zerovector, c, - core::vector2d(0,0)); - - f->material = material; - - return f; + if(data) + delete[] data; } - -/* - Parameters must consist of air and !air. - Order doesn't matter. - If either of the nodes doesn't exist, light is 0. -*/ -u8 MapBlock::getFaceLight(v3s16 p, v3s16 face_dir) +bool MapBlock::isValidPositionParent(v3s16 p) { - try{ - MapNode n = getNodeParent(p); - MapNode n2 = getNodeParent(p + face_dir); - u8 light; - /*if(n.solidness() < n2.solidness()) - light = n.getLight(); - else - light = n2.getLight();*/ - if(n.getLight() > n2.getLight()) - light = n.getLight(); - else - light = n2.getLight(); - - // Make some nice difference to different sides - - /*if(face_dir.X == 1 || face_dir.Z == 1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.X == -1 || face_dir.Z == -1) - light = diminish_light(light);*/ - - if(face_dir.X == 1 || face_dir.X == -1 || face_dir.Y == -1) - light = diminish_light(diminish_light(light)); - else if(face_dir.Z == 1 || face_dir.Z == -1) - light = diminish_light(light); - - return light; - } - catch(InvalidPositionException &e) + if(isValidPosition(p)) { - return 0; - } -} - -/* - Gets node material from any place relative to block. - Returns CONTENT_IGNORE if doesn't exist or should not be drawn. -*/ -u8 MapBlock::getNodeTile(v3s16 p) -{ - try{ - MapNode n = getNodeParent(p); - - return content_tile(n.d); + return true; } - catch(InvalidPositionException &e) - { - return CONTENT_IGNORE; + else{ + return m_parent->isValidPosition(getPosRelative() + p); } } -/* - startpos: - translate_dir: unit vector with only one of x, y or z - face_dir: unit vector with only one of x, y or z -*/ -void MapBlock::updateFastFaceRow(v3s16 startpos, - u16 length, - v3s16 translate_dir, - v3s16 face_dir, - core::list &dest) +MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position) { - /* - Precalculate some variables - */ - v3f translate_dir_f(translate_dir.X, translate_dir.Y, - translate_dir.Z); // floating point conversion - v3f face_dir_f(face_dir.X, face_dir.Y, - face_dir.Z); // floating point conversion - v3f posRelative_f(getPosRelative().X, getPosRelative().Y, - getPosRelative().Z); // floating point conversion - - v3s16 p = startpos; - /* - The light in the air lights the surface is taken from - the node that is air. - */ - u8 light = getFaceLight(p, face_dir); - - u16 continuous_tiles_count = 0; - - u8 tile0 = getNodeTile(p); - u8 tile1 = getNodeTile(p + face_dir); - - for(u16 j=0; jgetNodeNoEx(getPosRelative() + p, is_valid_position); - continuous_tiles_count = 0; - tile0 = tile0_next; - tile1 = tile1_next; - light = light_next; - } - - p = p_next; + 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 * zstride + p.Y * ystride + p.X]; } -/* - This is used because CMeshBuffer::append() is very slow -*/ -struct PreMeshBuffer -{ - video::SMaterial material; - core::array indices; - core::array vertices; -}; - -class MeshCollector -{ -public: - void append( - video::SMaterial material, - const video::S3DVertex* const vertices, - u32 numVertices, - const u16* const indices, - u32 numIndices - ) - { - PreMeshBuffer *p = NULL; - for(u32 i=0; ivertices.size(); - for(u32 i=0; i 65535) - { - dstream<<"FIXME: Meshbuffer ran out of indices"<indices.push_back(j); - } - for(u32 i=0; ivertices.push_back(vertices[i]); - } - } - - void fillMesh(scene::SMesh *mesh) - { - /*dstream<<"Filling mesh with "< - scene::SMeshBuffer *buf = new scene::SMeshBuffer(); - // Set material - buf->Material = p.material; - //((scene::SMeshBuffer*)buf)->Material = p.material; - // Use VBO - //buf->setHardwareMappingHint(scene::EHM_STATIC); - // Add to mesh - mesh->addMeshBuffer(buf); - // Mesh grabbed it - buf->drop(); - - buf->append(p.vertices.pointer(), p.vertices.size(), - p.indices.pointer(), p.indices.size()); - } - } - -private: - core::array m_prebuffers; -}; - -void MapBlock::updateMesh() +std::string MapBlock::getModifiedReasonString() { - /*v3s16 p = getPosRelative(); - std::cout<<"MapBlock("< *fastfaces_new = new core::list; - - /* - We are including the faces of the trailing edges of the block. - This means that when something changes, the caller must - also update the meshes of the blocks at the leading edges. - */ - - /* - Go through every y,z and get top faces in rows of x+ - */ - for(s16 y=0; ygetSize() > 0) - { - MeshCollector collector; - - core::list::Iterator i = fastfaces_new->begin(); - - for(; i != fastfaces_new->end(); i++) - { - FastFace *f = *i; - - const u16 indices[] = {0,1,2,2,3,0}; - - collector.append(g_materials[f->material], f->vertices, 4, - indices, 6); - } - - collector.fillMesh(mesh_new); - - // Use VBO for mesh (this just would set this for ever buffer) - //mesh_new->setHardwareMappingHint(scene::EHM_STATIC); - - /*std::cout<<"MapBlock has "<getSize()<<" faces " - <<"and uses "<getMeshBufferCount() - <<" materials (meshbuffers)"<::Iterator i; - i = fastfaces_new->begin(); - for(; i != fastfaces_new->end(); i++) - { - delete *i; - } - fastfaces_new->clear(); - delete fastfaces_new; - - /* - Add special graphics: - - torches - - TODO: Optimize by using same meshbuffer for same textures - */ - - /*scene::ISceneManager *smgr = NULL; - video::IVideoDriver* driver = NULL; - if(g_device) - { - smgr = g_device->getSceneManager(); - driver = smgr->getVideoDriver(); - }*/ - - for(s16 z=0; zappend(vertices, 4, indices, 6); - - // Set material - buf->getMaterial().setFlag(video::EMF_LIGHTING, false); - buf->getMaterial().setFlag(video::EMF_BACK_FACE_CULLING, false); - buf->getMaterial().setFlag(video::EMF_BILINEAR_FILTER, false); - //buf->getMaterial().MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL; - buf->getMaterial().MaterialType - = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF; - if(dir == v3s16(0,-1,0)) - buf->getMaterial().setTexture(0, - g_texturecache.get("torch_on_floor")); - else if(dir == v3s16(0,1,0)) - buf->getMaterial().setTexture(0, - g_texturecache.get("torch_on_ceiling")); - // For backwards compatibility - else if(dir == v3s16(0,0,0)) - buf->getMaterial().setTexture(0, - g_texturecache.get("torch_on_floor")); - else - buf->getMaterial().setTexture(0, g_texturecache.get("torch")); - - // Add to mesh - mesh_new->addMeshBuffer(buf); - buf->drop(); - } - } - - /* - Do some stuff to the mesh - */ + std::string reason; - mesh_new->recalculateBoundingBox(); + const u32 ubound = MYMIN(sizeof(m_modified_reason) * CHAR_BIT, + ARRLEN(modified_reason_strings)); - /* - Delete new mesh if it is empty - */ + for (u32 i = 0; i != ubound; i++) { + if ((m_modified_reason & (1 << i)) == 0) + continue; - if(mesh_new->getMeshBufferCount() == 0) - { - mesh_new->drop(); - mesh_new = NULL; + reason += modified_reason_strings[i]; + reason += ", "; } - /* - Replace the mesh - */ - - mesh_mutex.Lock(); - - scene::SMesh *mesh_old = mesh; - - mesh = mesh_new; - - 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; igetMeshBuffer(i); - }*/ - // Drop the mesh - mesh_old->drop(); - //delete mesh_old; - } + if (reason.length() > 2) + reason.resize(reason.length() - 2); - mesh_mutex.Unlock(); - - //std::cout<<"added "< & light_sources) +bool MapBlock::propagateSunlight(std::set & 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; - + v3s16 pos_relative = getPosRelative(); - + for(s16 x=0; xndef()) != LIGHT_SUN) { - /*if(is_underground) - { - no_sunlight = true; - }*/ no_sunlight = true; } } - catch(InvalidPositionException &e) + else { - no_top_block = true; - - // TODO: This makes over-ground roofed places sunlighted + //no_top_block = true; + + // NOTE: This makes over-ground roofed places sunlighted // Assume sunlight, unless is_underground==true if(is_underground) { no_sunlight = true; } - - // TODO: There has to be some way to allow this behaviour - // As of now, it just makes everything dark. + else + { + MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z)); + if(m_gamedef->ndef()->get(n).sunlight_propagates == false) + { + no_sunlight = true; + } + } + // NOTE: As of now, this just would make everything dark. // No sunlight here //no_sunlight = true; } +#endif +#if 0 // Doesn't work; nothing gets light. + bool no_sunlight = true; + bool no_top_block = false; + // Check if node above block has sunlight + try{ + MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z)); + if(n.getLight(LIGHTBANK_DAY) == LIGHT_SUN) + { + no_sunlight = false; + } + } + catch(InvalidPositionException &e) + { + no_top_block = true; + } +#endif /*std::cout<<"("< & light_sources) return block_below_is_valid; } + 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)); - + + // Copy from data to VoxelManipulator dst.copyFrom(data, data_area, v3s16(0,0,0), getPosRelative(), data_size); } -/*void getPseudoObjects(v3f origin, f32 max_d, - core::array &dest) +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)); + + // Copy from VoxelManipulator to data + dst.copyTo(data, data_area, v3s16(0,0,0), + getPosRelative(), data_size); +} + +void MapBlock::actuallyUpdateDayNightDiff() +{ + INodeDefManager *nodemgr = m_gamedef->ndef(); + + // Running this function un-expires m_day_night_differs + m_day_night_differs_expired = false; + + if (data == NULL) { + m_day_night_differs = false; + return; + } + + bool differs; + + /* + Check if any lighting value differs + */ + for (u32 i = 0; i < nodecount; i++) { + MapNode &n = data[i]; + + differs = !n.isLightDayNightEq(nodemgr); + if (differs) + break; + } + + /* + If some lighting values differ, check if the whole thing is + just air. If it is just air, differs = false + */ + if (differs) { + bool only_air = true; + for (u32 i = 0; i < nodecount; i++) { + MapNode &n = data[i]; + if (n.getContent() != CONTENT_AIR) { + only_air = false; + break; + } + } + if (only_air) + differs = false; + } + + // Set member variable + 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()) + return -3; + try + { + s16 y = MAP_BLOCKSIZE-1; + for(; y>=0; y--) + { + MapNode n = getNodeRef(p2d.X, y, p2d.Y); + if(m_gamedef->ndef()->get(n).walkable) + { + if(y == MAP_BLOCKSIZE-1) + return -2; + else + return y; + } + } + return -1; + } + catch(InvalidPositionException &e) + { + return -3; + } +} /* Serialization */ +// 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) +{ + memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t)); + + std::set unknown_contents; + content_t id_counter = 0; + for (u32 i = 0; i < MapBlock::nodecount; i++) { + content_t global_id = nodes[i].getContent(); + content_t id = CONTENT_IGNORE; + + // Try to find an existing mapping + if (getBlockNodeIdMapping_mapping[global_id] != 0xFFFF) { + id = getBlockNodeIdMapping_mapping[global_id]; + } + else + { + // We have to assign a new mapping + id = id_counter++; + getBlockNodeIdMapping_mapping[global_id] = id; + + const ContentFeatures &f = nodedef->get(global_id); + const std::string &name = f.name; + if(name == "") + unknown_contents.insert(global_id); + else + nimap->set(id, name); + } + + // Update the MapNode + nodes[i].setContent(id); + } + for(std::set::const_iterator + i = unknown_contents.begin(); + i != unknown_contents.end(); ++i){ + errorstream<<"getBlockNodeIdMapping(): IGNORING ERROR: " + <<"Name for node id "<<(*i)<<" not known"<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 unnamed_contents; + std::set unallocatable_contents; + for (u32 i = 0; i < MapBlock::nodecount; 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::const_iterator + i = unnamed_contents.begin(); + i != unnamed_contents.end(); ++i){ + errorstream<<"correctBlockNodeIds(): IGNORING ERROR: " + <<"Block contains id "<<(*i) + <<" with no name mapping"<::const_iterator + i = unallocatable_contents.begin(); + i != unallocatable_contents.end(); ++i){ + errorstream<<"correctBlockNodeIds(): IGNORING ERROR: " + <<"Could not allocate global id for node name \"" + <<(*i)<<"\""< dest(buflen); - dest[0] = is_underground; + FATAL_ERROR_IF(version < SER_FMT_VER_LOWEST_WRITE, "Serialisation version error"); + + // First byte + u8 flags = 0; + if(is_underground) + flags |= 0x01; + if(getDayNightDiff()) + flags |= 0x02; + if(m_generated == false) + flags |= 0x08; + writeU8(os, flags); + if (version >= 27) { + writeU16(os, m_lighting_complete); + } + + /* + Bulk node data + */ + NameIdMapping nimap; + if(disk) + { + MapNode *tmp_nodes = new MapNode[nodecount]; for(u32 i=0; indef()); + + 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 otherversions else { - /* - With compression. - Compress the materials and the params separately. - */ - - // First byte - os.write((char*)&is_underground, 1); + 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); + } - u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; + /* + Node metadata + */ + std::ostringstream oss(std::ios_base::binary); + m_node_metadata.serialize(oss); + compressZlib(oss.str(), os); - // Get and compress materials - SharedBuffer materialdata(nodecount); - for(u32 i=0; i lightdata(nodecount); - for(u32 i=0; i= 10) - { - // Get and compress pressure - SharedBuffer pressuredata(nodecount); - for(u32 i=0; i= 25){ + // Node timers + m_node_timers.serialize(os, version); } } } -void MapBlock::deSerialize(std::istream &is, u8 version) +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"); - // These have no compression - if(version <= 3 || version == 5 || version == 6) + TRACESTREAM(<<"MapBlock::deSerialize "< d(len); - is.read((char*)*d, len); - if(is.gcount() != len) - throw SerializationError - ("MapBlock::deSerialize: no enough input data"); - data[i].deSerialize(*d, version); + deSerialize_pre22(is, version, disk); + return; + } + + u8 flags = readU8(is); + is_underground = (flags & 0x01) ? true : false; + m_day_night_differs = (flags & 0x02) ? true : false; + if (version < 27) { + m_lighting_complete = 0xFFFF; + } else { + m_lighting_complete = readU16(is); + } + m_generated = (flags & 0x08) ? false : true; + + /* + Bulk node data + */ + TRACESTREAM(<<"MapBlock::deSerialize "<= 23) + m_node_metadata.deSerialize(iss, m_gamedef->idef()); + else + content_nodemeta_deserialize_legacy(iss, + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" + <<" while deserializing node metadata at (" + <= 25){ + TRACESTREAM(<<"MapBlock::deSerialize "<=25)"<= 1) { + readF1000(is); // deprecated heat + readF1000(is); // deprecated humidity + } + } + catch(SerializationError &e) { - u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; + warningstream<<"MapBlock::deSerializeNetworkSpecific(): Ignoring an error" + <<": "< databuf_nodelist(nodecount * ser_length); + + // These have no compression + if (version <= 3 || version == 5 || version == 6) { + char tmp; + is.read(&tmp, 1); + if (is.gcount() != 1) + throw SerializationError(std::string(FUNCTION_NAME) + + ": not enough input data"); + is_underground = tmp; + is.read((char *)*databuf_nodelist, nodecount * ser_length); + if ((u32)is.gcount() != nodecount * ser_length) + throw SerializationError(std::string(FUNCTION_NAME) + + ": not enough input data"); + } else if (version <= 10) { u8 t8; - is.read((char*)&t8, 1); + is.read((char *)&t8, 1); is_underground = t8; { @@ -899,12 +817,11 @@ void MapBlock::deSerialize(std::istream &is, u8 version) std::ostringstream os(std::ios_base::binary); decompress(is, os, version); std::string s = os.str(); - if(s.size() != nodecount) - throw SerializationError - ("MapBlock::deSerialize: invalid format"); - for(u32 i=0; i= 10) - { - // Uncompress and set pressure data + + if (version >= 10) { + // 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= 18) + m_generated = (flags & 0x08) ? false : true; + + // 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(std::string(FUNCTION_NAME) + + ": decompress resulted in size other than nodecount*3"); + + // deserialize nodes from buffer + for (u32 i = 0; i < nodecount; i++) { + databuf_nodelist[i*ser_length] = s[i]; + databuf_nodelist[i*ser_length + 1] = s[i+nodecount]; + databuf_nodelist[i*ser_length + 2] = s[i+nodecount*2]; + } + + /* + NodeMetadata + */ + if (version >= 14) { + // Ignore errors + try { + if (version <= 15) { + 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->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, + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); + } + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" + <<" while deserializing node metadata"<= 9) { + u16 count = readU16(is); + // Not supported and length not known if count is not 0 + if(count != 0){ + warningstream<<"MapBlock::deSerialize_pre22(): " + <<"Ignoring stuff coming at and after MBOs"<= 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); + } + + + // Legacy data changes + // This code has to convert from pre-22 to post-22 format. + INodeDefManager *nodedef = m_gamedef->ndef(); + for(u32 i=0; iget(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++) { - data[i].pressure = s[i]; + if((dir_old_format & wallmounted_new_to_old[j]) != 0) + { + dir_new_format = j; + break; + } } + data[i].setParam2(dir_new_format); } } + +} + +/* + Get a quick string to describe what a block actually contains +*/ +std::string analyze_block(MapBlock *block) +{ + if(block == NULL) + 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<getModified()) + { + 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())+", "; + } + + if(block->isGenerated()) + desc<<"is_gen [X], "; + else + desc<<"is_gen [ ], "; + + if(block->getIsUnderground()) + desc<<"is_ug [X], "; + else + desc<<"is_ug [ ], "; + + desc<<"lighting_complete: "<getLightingComplete()<<", "; + + if(block->isDummy()) + { + desc<<"Dummy, "; + } + else + { + bool full_ignore = true; + bool some_ignore = false; + bool full_air = true; + bool some_air = false; + for(s16 z0=0; z0getNodeNoEx(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<