X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmapblock.cpp;h=88f04e0bb56a0b14f14edf43839a694786279a5a;hb=f4fedfed070ffd85c3446bc5d38d2fbd577640d6;hp=2f6a4b850116522e8bd98c855f91819425ae8ec4;hpb=9d09103e481c4979ebb0130a9dee6265d0d6223b;p=dragonfireclient.git diff --git a/src/mapblock.cpp b/src/mapblock.cpp index 2f6a4b850..88f04e0bb 100644 --- a/src/mapblock.cpp +++ b/src/mapblock.cpp @@ -1,214 +1,141 @@ /* -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_settings -#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 */ -MapBlock::MapBlock(NodeContainer *parent, v3s16 pos, bool dummy): +MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy): m_parent(parent), m_pos(pos), - m_modified(MOD_STATE_WRITE_NEEDED), - is_underground(false), - m_lighting_expired(true), - m_day_night_differs(false), - m_generated(false), - m_objects(this), - m_timestamp(BLOCK_TIMESTAMP_UNDEFINED), - m_usage_timer(BLOCK_TIMESTAMP_UNDEFINED) + m_pos_relative(pos * MAP_BLOCKSIZE), + m_gamedef(gamedef) { - data = NULL; - if(dummy == false) + if (!dummy) reallocate(); - - //m_spawn_timer = -10000; - -#ifndef SERVER - m_mesh_expired = false; - mesh_mutex.Init(); - mesh = NULL; - m_temp_mods_mutex.Init(); -#endif } MapBlock::~MapBlock() { #ifndef SERVER { - JMutexAutoLock lock(mesh_mutex); - - if(mesh) - { - mesh->drop(); - mesh = NULL; - } + delete mesh; + mesh = nullptr; } #endif - if(data) - delete[] data; + delete[] data; } bool MapBlock::isValidPositionParent(v3s16 p) { - if(isValidPosition(p)) - { + if (isValidPosition(p)) { return true; } - else{ - return m_parent->isValidPosition(getPosRelative() + p); - } -} -MapNode MapBlock::getNodeParent(v3s16 p) -{ - if(isValidPosition(p) == false) - { - return m_parent->getNode(getPosRelative() + p); - } - else - { - if(data == NULL) - throw InvalidPositionException(); - return data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X]; - } + return m_parent->isValidPosition(getPosRelative() + p); } -void MapBlock::setNodeParent(v3s16 p, MapNode & n) +MapNode MapBlock::getNodeParent(v3s16 p, bool *is_valid_position) { - if(isValidPosition(p) == false) - { - m_parent->setNode(getPosRelative() + p, n); - } - else - { - if(data == NULL) - throw InvalidPositionException(); - data[p.Z*MAP_BLOCKSIZE*MAP_BLOCKSIZE + p.Y*MAP_BLOCKSIZE + p.X] = n; - } -} + if (!isValidPosition(p)) + return m_parent->getNodeNoEx(getPosRelative() + p, is_valid_position); -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]; - } -} - -#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; + if (!data) { + if (is_valid_position) + *is_valid_position = false; + return {CONTENT_IGNORE}; } -#endif - - MeshMakeData data; - data.fill(daynight_ratio, this); - - scene::SMesh *mesh_new = makeMapBlockMesh(&data); - - /* - Replace the mesh - */ - - replaceMesh(mesh_new); - + if (is_valid_position) + *is_valid_position = true; + return data[p.Z * zstride + p.Y * ystride + p.X]; } -#endif -void MapBlock::replaceMesh(scene::SMesh *mesh_new) +std::string MapBlock::getModifiedReasonString() { - mesh_mutex.Lock(); - - //scene::SMesh *mesh_old = mesh[daynight_i]; - //mesh[daynight_i] = mesh_new; + std::string reason; - 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; igetMeshBuffer(i); - }*/ - - /*dstream<<"mesh_old->getReferenceCount()=" - <getReferenceCount()<getMeshBufferCount(); - for(u32 i=0; igetMeshBuffer(i); - dstream<<"buf->getReferenceCount()=" - <getReferenceCount()<drop(); + for (u32 i = 0; i != ubound; i++) { + if ((m_modified_reason & (1 << i)) == 0) + continue; - //delete mesh_old; + reason += modified_reason_strings[i]; + reason += ", "; } - mesh_mutex.Unlock(); + if (reason.length() > 2) + reason.resize(reason.length() - 2); + + return reason; } - -#endif // !SERVER /* 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. @@ -224,33 +151,45 @@ void MapBlock::replaceMesh(scene::SMesh *mesh_new) if black_air_left!=NULL, it is set to true if non-sunlighted air is left in block. */ -bool MapBlock::propagateSunlight(core::map & 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) { 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) @@ -259,10 +198,8 @@ bool MapBlock::propagateSunlight(core::map & light_sources, } else { - MapNode n = getNode(v3s16(x, MAP_BLOCKSIZE-1, z)); - //if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE) - if(content_features(n.d).sunlight_propagates == false) - { + MapNode n = getNodeNoEx(v3s16(x, MAP_BLOCKSIZE-1, z)); + if (!m_gamedef->ndef()->get(n).sunlight_propagates) { no_sunlight = true; } } @@ -293,52 +230,30 @@ bool MapBlock::propagateSunlight(core::map & light_sources, <<", is_underground="<ndef(); + // Running this function un-expires m_day_night_differs + m_day_night_differs_expired = false; -void MapBlock::updateDayNightDiff() -{ - if(data == NULL) - { + if (!data) { m_day_night_differs = false; return; } @@ -453,33 +361,35 @@ void MapBlock::updateDayNightDiff() /* Check if any lighting value differs */ - for(u32 i=0; i=0; y--) { - //if(is_ground_content(getNodeRef(p2d.X, y, p2d.Y).d)) - if(content_features(getNodeRef(p2d.X, y, p2d.Y).d).walkable) - { + 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 y; } } return -1; @@ -516,197 +436,365 @@ s16 MapBlock::getGroundLevel(v2s16 p2d) /* Serialization */ - -void MapBlock::serialize(std::ostream &os, u8 version) +// 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) { - if(!ser_ver_supported(version)) - throw VersionMismatchException("ERROR: MapBlock format not supported"); - - if(data == NULL) - { - 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 dest(buflen); + memset(getBlockNodeIdMapping_mapping, 0xFF, (USHRT_MAX + 1) * sizeof(content_t)); - dest[0] = is_underground; - for(u32 i=0; i 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 { - u32 s = 1 + i * MapNode::serializedLength(version); - data[i].serialize(&dest[s], version); + // 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.empty()) + unknown_contents.insert(global_id); + else + nimap->set(id, name); } - - os.write((char*)*dest, dest.getSize()); - } - else if(version <= 10) - { - /* - 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 materialdata(nodecount); - for(u32 i=0; indef(); + // 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::unordered_set unnamed_contents; + std::unordered_set unallocatable_contents; + + bool previous_exists = false; + content_t previous_local_id = CONTENT_IGNORE; + content_t previous_global_id = CONTENT_IGNORE; + + for (u32 i = 0; i < MapBlock::nodecount; i++) { + content_t local_id = nodes[i].getContent(); + // If previous node local_id was found and same than before, don't lookup maps + // apply directly previous resolved id + // This permits to massively improve loading performance when nodes are similar + // example: default:air, default:stone are massively present + if (previous_exists && local_id == previous_local_id) { + nodes[i].setContent(previous_global_id); + continue; } - compress(materialdata, os, version); - // Get and compress lights - SharedBuffer lightdata(nodecount); - for(u32 i=0; igetName(local_id, name)) { + unnamed_contents.insert(local_id); + previous_exists = false; + continue; } - compress(lightdata, os, version); - - if(version >= 10) - { - // Get and compress param2 - SharedBuffer param2data(nodecount); - for(u32 i=0; igetId(name, global_id)) { + global_id = gamedef->allocateUnknownNodeId(name); + if (global_id == CONTENT_IGNORE) { + unallocatable_contents.insert(name); + previous_exists = false; + continue; } - compress(param2data, os, version); } + nodes[i].setContent(global_id); + + // Save previous node local_id & global_id result + previous_local_id = local_id; + previous_global_id = global_id; + previous_exists = true; } - // 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; - } - os.write((char*)&flags, 1); - u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; + for (const content_t c: unnamed_contents) { + errorstream << "correctBlockNodeIds(): IGNORING ERROR: " + << "Block contains id " << c + << " with no name mapping" << std::endl; + } + for (const std::string &node_name: unallocatable_contents) { + errorstream << "correctBlockNodeIds(): IGNORING ERROR: " + << "Could not allocate global id for node name \"" + << node_name << "\"" << std::endl; + } +} - /* - Get data - */ +void MapBlock::serialize(std::ostream &os, u8 version, bool disk) +{ + if(!ser_ver_supported(version)) + throw VersionMismatchException("ERROR: MapBlock format not supported"); - SharedBuffer databuf(nodecount*3); + if (!data) + throw SerializationError("ERROR: Not writing dummy block."); - // Get contents - for(u32 i=0; i= 27) { + writeU16(os, m_lighting_complete); + } - // Get params + /* + 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; + } + else + { + 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); + } - // Get param2 - for(u32 i=0; i= 14) - { - if(version <= 15) - { - try{ - std::ostringstream oss(std::ios_base::binary); - m_node_metadata.serialize(oss); - os<= 25){ + // Node timers + m_node_timers.serialize(os, version); } } } -void MapBlock::deSerialize(std::istream &is, u8 version) +void MapBlock::serializeNetworkSpecific(std::ostream &os) +{ + if (!data) { + throw SerializationError("ERROR: Not writing dummy block."); + } + + writeU8(os, 1); // version + writeF1000(os, 0); // deprecated heat + writeF1000(os, 0); // deprecated humidity +} + +void MapBlock::deSerialize(std::istream &is, u8 version, bool disk) { if(!ser_ver_supported(version)) throw VersionMismatchException("ERROR: MapBlock format not supported"); - // These have no lighting info - if(version <= 1) + 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 (" + < d(len); - is.read((char*)*d, len); - if(is.gcount() != len) - throw SerializationError - ("MapBlock::deSerialize: no enough input data"); - data[i].deSerialize(*d, version); + // Node timers + if(version == 23){ + // Read unused zero + readU8(is); + } + if(version == 24){ + TRACESTREAM(<<"MapBlock::deSerialize "<= 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; { @@ -714,12 +802,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) - { + + 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; + m_generated = (flags & 0x08) == 0; // Uncompress data std::ostringstream os(std::ios_base::binary); decompress(is, os, version); std::string s = os.str(); - if(s.size() != nodecount*3) - throw SerializationError - ("MapBlock::deSerialize: decompress resulted in size" - " other than nodecount*3"); - - // Set contents - for(u32 i=0; i= 14) - { + if (version >= 14) { // Ignore errors - try{ - if(version <= 15) - { + try { + if (version <= 15) { std::string data = deSerializeString(is); std::istringstream iss(data, std::ios_base::binary); - m_node_metadata.deSerialize(iss); - } - else - { + 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); - m_node_metadata.deSerialize(iss); + content_nodemeta_deserialize_legacy(iss, + &m_node_metadata, &m_node_timers, + m_gamedef->idef()); } - } - catch(SerializationError &e) - { - dstream<<"WARNING: MapBlock::deSerialize(): Ignoring an error" + } catch(SerializationError &e) { + warningstream<<"MapBlock::deSerialize(): Ignoring an error" <<" while deserializing node metadata"<d<= 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"<= 9) - { - //serializeObjects(os, version); // DEPRECATED - // count=0 - writeU16(os, 0); - } - - // Versions up from 15 have static objects. - if(version >= 15) - { - m_static_objects.serialize(os); + /* + 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; 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++) + { + 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[25]; + snprintf(spos, sizeof(spos), "(%2d,%2d,%2d), ", p.X, p.Y, p.Z); + desc<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 [ ], "; + + desc<<"lighting_complete: "<getLightingComplete()<<", "; + + 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; 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<