*/
#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
/*
MapBlock
*/
-MapBlock::MapBlock(Map *parent, v3s16 pos, bool dummy):
+MapBlock::MapBlock(Map *parent, v3s16 pos, IGameDef *gamedef, bool dummy):
+ m_node_metadata(new NodeMetadataList),
m_parent(parent),
m_pos(pos),
+ m_gamedef(gamedef),
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(0)
{
if(dummy == false)
reallocate();
- //m_spawn_timer = -10000;
-
#ifndef SERVER
m_mesh_expired = false;
mesh_mutex.Init();
}
#endif
+ delete m_node_metadata;
+
if(data)
delete[] data;
}
MeshMakeData data;
data.fill(daynight_ratio, this);
- scene::SMesh *mesh_new = makeMapBlockMesh(&data);
+ scene::SMesh *mesh_new = makeMapBlockMesh(&data, m_gamedef);
/*
Replace the mesh
IMeshBuffer *buf = mesh_old->getMeshBuffer(i);
}*/
- /*dstream<<"mesh_old->getReferenceCount()="
+ /*infostream<<"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()="
+ infostream<<"buf->getReferenceCount()="
<<buf->getReferenceCount()<<std::endl;
}*/
bool MapBlock::propagateSunlight(core::map<v3s16, bool> & 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;
// Check if node above block has sunlight
try{
MapNode n = getNodeParent(v3s16(x, MAP_BLOCKSIZE, z));
- if(n.d == CONTENT_IGNORE || n.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
+ if(n.getContent() == CONTENT_IGNORE)
+ {
+ // Trust heuristics
+ no_sunlight = is_underground;
+ }
+ 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.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
- if(content_features(n.d).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)).d == CONTENT_AIR)
- upper_is_air = true;
- }
- catch(InvalidPositionException &e)
- {
- }
- // Turn mud into grass
- if(upper_is_air && n.d == 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)
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)
-{
- /*
- Step objects
- */
- m_objects.step(dtime, server, daynight_ratio);
-
- setChangedFlag();
-}
-
-
void MapBlock::updateDayNightDiff()
{
+ INodeDefManager *nodemgr = m_gamedef->ndef();
+
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;
for(u32 i=0; i<MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE; i++)
{
MapNode &n = data[i];
- if(n.d != CONTENT_AIR)
+ if(n.getContent() != CONTENT_AIR)
{
only_air = false;
break;
s16 y = MAP_BLOCKSIZE-1;
for(; y>=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;
Serialization
*/
+// List relevant id-name pairs for ids in the block using nodedef
+static void getBlockNodeIdMapping(NameIdMapping *nimap, MapBlock *block,
+ INodeDefManager *nodedef)
+{
+ std::set<content_t> unknown_contents;
+ 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 id = n.getContent();
+ const ContentFeatures &f = nodedef->get(id);
+ const std::string &name = f.name;
+ if(name == "")
+ unknown_contents.insert(id);
+ else
+ nimap->set(id, name);
+ }
+ 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.
+void correctBlockNodeIds(const NameIdMapping *nimap, MapBlock *block,
+ 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(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 local_id = n.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;
+ }
+ }
+ n.setContent(global_id);
+ block->setNode(p, n);
+ }
+ 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)
{
if(!ser_ver_supported(version))
SharedBuffer<u8> materialdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
- materialdata[i] = data[i].d;
+ materialdata[i] = data[i].param0;
}
compress(materialdata, os, version);
SharedBuffer<u8> lightdata(nodecount);
for(u32 i=0; i<nodecount; i++)
{
- lightdata[i] = data[i].param;
+ lightdata[i] = data[i].param1;
}
compress(lightdata, os, version);
flags |= 0x08;
}
os.write((char*)&flags, 1);
-
+
u32 nodecount = MAP_BLOCKSIZE*MAP_BLOCKSIZE*MAP_BLOCKSIZE;
/*
{
try{
std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
+ m_node_metadata->serialize(oss);
os<<serializeString(oss.str());
}
// This will happen if the string is longer than 65535
else
{
std::ostringstream oss(std::ios_base::binary);
- m_node_metadata.serialize(oss);
+ m_node_metadata->serialize(oss);
compressZlib(oss.str(), os);
//os<<serializeLongString(oss.str());
}
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].d = s[i];
+ data[i].param0 = s[i];
}
}
{
("MapBlock::deSerialize: invalid format");
for(u32 i=0; i<s.size(); i++)
{
- data[i].param = s[i];
+ data[i].param1 = s[i];
}
}
{
std::string data = deSerializeString(is);
std::istringstream iss(data, std::ios_base::binary);
- m_node_metadata.deSerialize(iss);
+ m_node_metadata->deSerialize(iss, 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);
+ m_node_metadata->deSerialize(iss, 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.
+ // Versions up from 9 have block objects. (DEPRECATED)
if(version >= 9)
{
- //serializeObjects(os, version); // DEPRECATED
// count=0
writeU16(os, 0);
}
{
writeU32(os, getTimestamp());
}
+
+ // Scan and write node definition id mapping
+ if(version >= 21){
+ NameIdMapping nimap;
+ getBlockNodeIdMapping(&nimap, this, m_gamedef->ndef());
+ nimap.serialize(os);
+ }
}
void MapBlock::deSerializeDiskExtra(std::istream &is, u8 version)
{
/*
- Versions up from 9 have block objects.
+ Versions up from 9 have block objects. (DEPRECATED)
*/
- if(version >= 9)
- {
- updateObjects(is, version, NULL, 0);
+ if(version >= 9){
+ u16 count = readU16(is);
+ // Not supported and length not known if count is not 0
+ if(count != 0){
+ errorstream<<"WARNING: MapBlock::deSerializeDiskExtra(): "
+ <<"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));
+ 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, this, m_gamedef);
+}
+
+/*
+ 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<<spos;
+
+ switch(block->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 [ ], ";
+
+#ifndef SERVER
+ if(block->getMeshExpired())
+ desc<<"mesh_exp [X], ";
+ else
+ desc<<"mesh_exp [ ], ";
+#endif
+
+ if(block->getLightingExpired())
+ desc<<"lighting_exp [X], ";
+ else
+ desc<<"lighting_exp [ ], ";
+
+ if(block->isDummy())
{
- setTimestamp(BLOCK_TIMESTAMP_UNDEFINED);
+ desc<<"Dummy, ";
+ }
+ else
+ {
+ 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);
}