#include "environment.h"
#include "emerge.h"
#include "mapgen_v6.h"
-#include "biome.h"
+#include "mg_biome.h"
#include "config.h"
#include "server.h"
#include "database.h"
Map::Map(std::ostream &dout, IGameDef *gamedef):
m_dout(dout),
m_gamedef(gamedef),
- m_sector_cache(NULL)
+ m_sector_cache(NULL),
+ m_transforming_liquid_loop_count_multiplier(1.0f),
+ m_unprocessed_count(0),
+ m_inc_trending_up_start_time(0),
+ m_queue_size_timer_started(false)
{
}
}
// Returns a CONTENT_IGNORE node if not found
-MapNode Map::getNodeNoEx(v3s16 p)
+MapNode Map::getNodeNoEx(v3s16 p, bool *is_valid_position)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
- if(block == NULL)
+ if (block == NULL) {
+ if (is_valid_position != NULL)
+ *is_valid_position = false;
return MapNode(CONTENT_IGNORE);
+ }
+
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- return block->getNodeNoCheck(relpos);
+ bool is_valid_p;
+ MapNode node = block->getNodeNoCheck(relpos, &is_valid_p);
+ if (is_valid_position != NULL)
+ *is_valid_position = is_valid_p;
+ return node;
}
+#if 0
+// Deprecated
// throws InvalidPositionException if not found
+// TODO: Now this is deprecated, getNodeNoEx should be renamed
MapNode Map::getNode(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
- if(block == NULL)
+ if (block == NULL)
throw InvalidPositionException();
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- return block->getNodeNoCheck(relpos);
+ bool is_valid_position;
+ MapNode node = block->getNodeNoCheck(relpos, &is_valid_position);
+ if (!is_valid_position)
+ throw InvalidPositionException();
+ return node;
}
+#endif
// throws InvalidPositionException if not found
void Map::setNode(v3s16 p, MapNode & n)
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
// Never allow placing CONTENT_IGNORE, it fucks up stuff
if(n.getContent() == CONTENT_IGNORE){
+ bool temp_bool;
errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
<<" while trying to replace \""
- <<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos)).name
+ <<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos, &temp_bool)).name
<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
debug_stacks_print_to(infostream);
return;
v3s16(-1,0,0), // left
};
- if(from_nodes.size() == 0)
+ if(from_nodes.empty())
return;
u32 blockchangecount = 0;
// Get the block where the node is located
v3s16 blockpos = getNodeBlockPos(n2pos);
- try
- {
- // Only fetch a new block if the block position has changed
- try{
- if(block == NULL || blockpos != blockpos_last){
- block = getBlockNoCreate(blockpos);
- blockpos_last = blockpos;
+ // Only fetch a new block if the block position has changed
+ try {
+ if(block == NULL || blockpos != blockpos_last){
+ block = getBlockNoCreate(blockpos);
+ blockpos_last = blockpos;
- block_checked_in_modified = false;
- blockchangecount++;
- }
- }
- catch(InvalidPositionException &e)
- {
- continue;
+ block_checked_in_modified = false;
+ blockchangecount++;
}
+ }
+ catch(InvalidPositionException &e) {
+ continue;
+ }
- // Calculate relative position in block
- v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
- // Get node straight from the block
- MapNode n2 = block->getNode(relpos);
+ // Calculate relative position in block
+ v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
+ // Get node straight from the block
+ bool is_valid_position;
+ MapNode n2 = block->getNode(relpos, &is_valid_position);
+ if (!is_valid_position)
+ continue;
- bool changed = false;
+ bool changed = false;
- //TODO: Optimize output by optimizing light_sources?
+ //TODO: Optimize output by optimizing light_sources?
+ /*
+ If the neighbor is dimmer than what was specified
+ as oldlight (the light of the previous node)
+ */
+ if(n2.getLight(bank, nodemgr) < oldlight)
+ {
/*
- If the neighbor is dimmer than what was specified
- as oldlight (the light of the previous node)
+ And the neighbor is transparent and it has some light
*/
- if(n2.getLight(bank, nodemgr) < oldlight)
+ if(nodemgr->get(n2).light_propagates
+ && n2.getLight(bank, nodemgr) != 0)
{
/*
- And the neighbor is transparent and it has some light
+ Set light to 0 and add to queue
*/
- if(nodemgr->get(n2).light_propagates
- && n2.getLight(bank, nodemgr) != 0)
- {
- /*
- Set light to 0 and add to queue
- */
-
- u8 current_light = n2.getLight(bank, nodemgr);
- n2.setLight(bank, 0, nodemgr);
- block->setNode(relpos, n2);
-
- unlighted_nodes[n2pos] = current_light;
- changed = true;
-
- /*
- Remove from light_sources if it is there
- NOTE: This doesn't happen nearly at all
- */
- /*if(light_sources.find(n2pos))
- {
- infostream<<"Removed from light_sources"<<std::endl;
- light_sources.remove(n2pos);
- }*/
- }
- /*// DEBUG
- if(light_sources.find(n2pos) != NULL)
- light_sources.remove(n2pos);*/
- }
- else{
- light_sources.insert(n2pos);
- }
+ u8 current_light = n2.getLight(bank, nodemgr);
+ n2.setLight(bank, 0, nodemgr);
+ block->setNode(relpos, n2);
- // Add to modified_blocks
- if(changed == true && block_checked_in_modified == false)
- {
- // If the block is not found in modified_blocks, add.
- if(modified_blocks.find(blockpos) == modified_blocks.end())
+ unlighted_nodes[n2pos] = current_light;
+ changed = true;
+
+ /*
+ Remove from light_sources if it is there
+ NOTE: This doesn't happen nearly at all
+ */
+ /*if(light_sources.find(n2pos))
{
- modified_blocks[blockpos] = block;
- }
- block_checked_in_modified = true;
+ infostream<<"Removed from light_sources"<<std::endl;
+ light_sources.remove(n2pos);
+ }*/
}
+
+ /*// DEBUG
+ if(light_sources.find(n2pos) != NULL)
+ light_sources.remove(n2pos);*/
}
- catch(InvalidPositionException &e)
+ else{
+ light_sources.insert(n2pos);
+ }
+
+ // Add to modified_blocks
+ if(changed == true && block_checked_in_modified == false)
{
- continue;
+ // If the block is not found in modified_blocks, add.
+ if(modified_blocks.find(blockpos) == modified_blocks.end())
+ {
+ modified_blocks[blockpos] = block;
+ }
+ block_checked_in_modified = true;
}
}
}
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
- if(unlighted_nodes.size() > 0)
+ if(!unlighted_nodes.empty())
unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
}
v3s16(-1,0,0), // left
};
- if(from_nodes.size() == 0)
+ if(from_nodes.empty())
return;
u32 blockchangecount = 0;
v3s16 blockpos = getNodeBlockPos(pos);
// Only fetch a new block if the block position has changed
- try{
+ try {
if(block == NULL || blockpos != blockpos_last){
block = getBlockNoCreate(blockpos);
blockpos_last = blockpos;
blockchangecount++;
}
}
- catch(InvalidPositionException &e)
- {
+ catch(InvalidPositionException &e) {
continue;
}
v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
// Get node straight from the block
- MapNode n = block->getNode(relpos);
+ bool is_valid_position;
+ MapNode n = block->getNode(relpos, &is_valid_position);
- u8 oldlight = n.getLight(bank, nodemgr);
+ u8 oldlight = is_valid_position ? n.getLight(bank, nodemgr) : 0;
u8 newlight = diminish_light(oldlight);
// Loop through 6 neighbors
// Get the block where the node is located
v3s16 blockpos = getNodeBlockPos(n2pos);
- try
- {
- // Only fetch a new block if the block position has changed
- try{
- if(block == NULL || blockpos != blockpos_last){
- block = getBlockNoCreate(blockpos);
- blockpos_last = blockpos;
+ // Only fetch a new block if the block position has changed
+ try {
+ if(block == NULL || blockpos != blockpos_last){
+ block = getBlockNoCreate(blockpos);
+ blockpos_last = blockpos;
- block_checked_in_modified = false;
- blockchangecount++;
- }
- }
- catch(InvalidPositionException &e)
- {
- continue;
+ block_checked_in_modified = false;
+ blockchangecount++;
}
+ }
+ catch(InvalidPositionException &e) {
+ continue;
+ }
- // Calculate relative position in block
- v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
- // Get node straight from the block
- MapNode n2 = block->getNode(relpos);
+ // Calculate relative position in block
+ v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
+ // Get node straight from the block
+ MapNode n2 = block->getNode(relpos, &is_valid_position);
+ if (!is_valid_position)
+ continue;
- bool changed = false;
- /*
- If the neighbor is brighter than the current node,
- add to list (it will light up this node on its turn)
- */
- if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
+ bool changed = false;
+ /*
+ If the neighbor is brighter than the current node,
+ add to list (it will light up this node on its turn)
+ */
+ if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
+ {
+ lighted_nodes.insert(n2pos);
+ changed = true;
+ }
+ /*
+ If the neighbor is dimmer than how much light this node
+ would spread on it, add to list
+ */
+ if(n2.getLight(bank, nodemgr) < newlight)
+ {
+ if(nodemgr->get(n2).light_propagates)
{
+ n2.setLight(bank, newlight, nodemgr);
+ block->setNode(relpos, n2);
lighted_nodes.insert(n2pos);
changed = true;
}
- /*
- If the neighbor is dimmer than how much light this node
- would spread on it, add to list
- */
- if(n2.getLight(bank, nodemgr) < newlight)
- {
- if(nodemgr->get(n2).light_propagates)
- {
- n2.setLight(bank, newlight, nodemgr);
- block->setNode(relpos, n2);
- lighted_nodes.insert(n2pos);
- changed = true;
- }
- }
+ }
- // Add to modified_blocks
- if(changed == true && block_checked_in_modified == false)
+ // Add to modified_blocks
+ if(changed == true && block_checked_in_modified == false)
+ {
+ // If the block is not found in modified_blocks, add.
+ if(modified_blocks.find(blockpos) == modified_blocks.end())
{
- // If the block is not found in modified_blocks, add.
- if(modified_blocks.find(blockpos) == modified_blocks.end())
- {
- modified_blocks[blockpos] = block;
- }
- block_checked_in_modified = true;
+ modified_blocks[blockpos] = block;
}
- }
- catch(InvalidPositionException &e)
- {
- continue;
+ block_checked_in_modified = true;
}
}
}
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
- if(lighted_nodes.size() > 0)
+ if(!lighted_nodes.empty())
spreadLight(bank, lighted_nodes, modified_blocks);
}
// Get the position of the neighbor node
v3s16 n2pos = p + dirs[i];
MapNode n2;
- try{
- n2 = getNode(n2pos);
- }
- catch(InvalidPositionException &e)
- {
+ bool is_valid_position;
+ n2 = getNodeNoEx(n2pos, &is_valid_position);
+ if (!is_valid_position)
continue;
- }
+
if(n2.getLight(bank, nodemgr) > brightest_light || found_something == false){
brightest_light = n2.getLight(bank, nodemgr);
brightest_pos = n2pos;
}
v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE;
- MapNode n = block->getNode(relpos);
+ bool is_valid_position;
+ MapNode n = block->getNode(relpos, &is_valid_position);
+ if (!is_valid_position)
+ break;
if(nodemgr->get(n).sunlight_propagates)
{
for(s16 x=0; x<MAP_BLOCKSIZE; x++)
for(s16 y=0; y<MAP_BLOCKSIZE; y++)
{
-
- try{
- v3s16 p(x,y,z);
- MapNode n = block->getNode(p);
- u8 oldlight = n.getLight(bank, nodemgr);
- n.setLight(bank, 0, nodemgr);
- block->setNode(p, n);
-
- // If node sources light, add to list
- u8 source = nodemgr->get(n).light_source;
- if(source != 0)
- light_sources.insert(p + posnodes);
-
- // Collect borders for unlighting
- if((x==0 || x == MAP_BLOCKSIZE-1
- || y==0 || y == MAP_BLOCKSIZE-1
- || z==0 || z == MAP_BLOCKSIZE-1)
- && oldlight != 0)
- {
- v3s16 p_map = p + posnodes;
- unlight_from[p_map] = oldlight;
- }
- }
- catch(InvalidPositionException &e)
- {
- /*
- This would happen when dealing with a
- dummy block.
+ v3s16 p(x,y,z);
+ bool is_valid_position;
+ MapNode n = block->getNode(p, &is_valid_position);
+ if (!is_valid_position) {
+ /* This would happen when dealing with a
+ dummy block.
*/
- //assert(0);
infostream<<"updateLighting(): InvalidPositionException"
<<std::endl;
+ continue;
}
+ u8 oldlight = n.getLight(bank, nodemgr);
+ n.setLight(bank, 0, nodemgr);
+ block->setNode(p, n);
+
+ // If node sources light, add to list
+ u8 source = nodemgr->get(n).light_source;
+ if(source != 0)
+ light_sources.insert(p + posnodes);
+
+ // Collect borders for unlighting
+ if((x==0 || x == MAP_BLOCKSIZE-1
+ || y==0 || y == MAP_BLOCKSIZE-1
+ || z==0 || z == MAP_BLOCKSIZE-1)
+ && oldlight != 0)
+ {
+ v3s16 p_map = p + posnodes;
+ unlight_from[p_map] = oldlight;
+ }
+
+
}
if(bank == LIGHTBANK_DAY)
Otherwise there probably is.
*/
- try{
- MapNode topnode = getNode(toppos);
- if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
- node_under_sunlight = false;
- }
- catch(InvalidPositionException &e)
- {
- }
+ bool is_valid_position;
+ MapNode topnode = getNodeNoEx(toppos, &is_valid_position);
+
+ if(is_valid_position && topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
+ node_under_sunlight = false;
/*
Remove all light that has come out of this node
{
enum LightBank bank = banks[i];
- u8 lightwas = getNode(p).getLight(bank, ndef);
+ u8 lightwas = getNodeNoEx(p).getLight(bank, ndef);
// Add the block of the added node to modified_blocks
v3s16 blockpos = getNodeBlockPos(p);
v3s16 n2pos(p.X, y, p.Z);
MapNode n2;
- try{
- n2 = getNode(n2pos);
- }
- catch(InvalidPositionException &e)
- {
+
+ n2 = getNodeNoEx(n2pos, &is_valid_position);
+ if (!is_valid_position)
break;
- }
if(n2.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN)
{
};
for(u16 i=0; i<7; i++)
{
- try
- {
-
v3s16 p2 = p + dirs[i];
- MapNode n2 = getNode(p2);
- if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+ MapNode n2 = getNodeNoEx(p2, &is_valid_position);
+ if(is_valid_position
+ && (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
{
m_transforming_liquid.push_back(p2);
}
-
- }catch(InvalidPositionException &e)
- {
- }
}
}
If there is a node at top and it doesn't have sunlight,
there will be no sunlight going down.
*/
- try{
- MapNode topnode = getNode(toppos);
+ bool is_valid_position;
+ MapNode topnode = getNodeNoEx(toppos, &is_valid_position);
- if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
- node_under_sunlight = false;
- }
- catch(InvalidPositionException &e)
- {
- }
+ if(is_valid_position && topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
+ node_under_sunlight = false;
std::set<v3s16> light_sources;
Unlight neighbors (in case the node is a light source)
*/
unLightNeighbors(bank, p,
- getNode(p).getLight(bank, ndef),
+ getNodeNoEx(p).getLight(bank, ndef),
light_sources, modified_blocks);
}
{
// Set the lighting of this node to 0
// TODO: Is this needed? Lighting is cleared up there already.
- try{
- MapNode n = getNode(p);
+ MapNode n = getNodeNoEx(p, &is_valid_position);
+ if (is_valid_position) {
n.setLight(LIGHTBANK_DAY, 0, ndef);
setNode(p, n);
- }
- catch(InvalidPositionException &e)
- {
+ } else {
assert(0);
}
}
};
for(u16 i=0; i<7; i++)
{
- try
- {
-
v3s16 p2 = p + dirs[i];
- MapNode n2 = getNode(p2);
- if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+ bool is_position_valid;
+ MapNode n2 = getNodeNoEx(p2, &is_position_valid);
+ if (is_position_valid
+ && (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
{
m_transforming_liquid.push_back(p2);
}
-
- }catch(InvalidPositionException &e)
- {
- }
}
}
void Map::transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks)
{
+
INodeDefManager *nodemgr = m_gamedef->ndef();
DSTACK(__FUNCTION_NAME);
// List of MapBlocks that will require a lighting update (due to lava)
std::map<v3s16, MapBlock*> lighting_modified_blocks;
- u16 loop_max = g_settings->getU16("liquid_loop_max");
+ u32 liquid_loop_max = g_settings->getS32("liquid_loop_max");
+ u32 loop_max = liquid_loop_max;
+
+#if 0
+
+ /* If liquid_loop_max is not keeping up with the queue size increase
+ * loop_max up to a maximum of liquid_loop_max * dedicated_server_step.
+ */
+ if (m_transforming_liquid.size() > loop_max * 2) {
+ // "Burst" mode
+ float server_step = g_settings->getFloat("dedicated_server_step");
+ if (m_transforming_liquid_loop_count_multiplier - 1.0 < server_step)
+ m_transforming_liquid_loop_count_multiplier *= 1.0 + server_step / 10;
+ } else {
+ m_transforming_liquid_loop_count_multiplier = 1.0;
+ }
+
+ loop_max *= m_transforming_liquid_loop_count_multiplier;
+#endif
while(m_transforming_liquid.size() != 0)
{
while (must_reflow.size() > 0)
m_transforming_liquid.push_back(must_reflow.pop_front());
updateLighting(lighting_modified_blocks, modified_blocks);
+
+
+ /* ----------------------------------------------------------------------
+ * Manage the queue so that it does not grow indefinately
+ */
+ u16 time_until_purge = g_settings->getU16("liquid_queue_purge_time");
+
+ if (time_until_purge == 0)
+ return; // Feature disabled
+
+ time_until_purge *= 1000; // seconds -> milliseconds
+
+ u32 curr_time = getTime(PRECISION_MILLI);
+ u32 prev_unprocessed = m_unprocessed_count;
+ m_unprocessed_count = m_transforming_liquid.size();
+
+ // if unprocessed block count is decreasing or stable
+ if (m_unprocessed_count <= prev_unprocessed) {
+ m_queue_size_timer_started = false;
+ } else {
+ if (!m_queue_size_timer_started)
+ m_inc_trending_up_start_time = curr_time;
+ m_queue_size_timer_started = true;
+ }
+
+ // Account for curr_time overflowing
+ if (m_queue_size_timer_started && m_inc_trending_up_start_time > curr_time)
+ m_queue_size_timer_started = false;
+
+ /* If the queue has been growing for more than liquid_queue_purge_time seconds
+ * and the number of unprocessed blocks is still > liquid_loop_max then we
+ * cannot keep up; dump the oldest blocks from the queue so that the queue
+ * has liquid_loop_max items in it
+ */
+ if (m_queue_size_timer_started
+ && curr_time - m_inc_trending_up_start_time > time_until_purge
+ && m_unprocessed_count > liquid_loop_max) {
+
+ size_t dump_qty = m_unprocessed_count - liquid_loop_max;
+
+ infostream << "transformLiquids(): DUMPING " << dump_qty
+ << " blocks from the queue" << std::endl;
+
+ while (dump_qty--)
+ m_transforming_liquid.pop_front();
+
+ m_queue_size_timer_started = false; // optimistically assume we can keep up now
+ m_unprocessed_count = m_transforming_liquid.size();
+ }
}
NodeMetadata *Map::getNodeMetadata(v3s16 p)
void ServerMap::prepareBlock(MapBlock *block) {
}
+// N.B. This requires no synchronization, since data will not be modified unless
+// the VoxelManipulator being updated belongs to the same thread.
+void ServerMap::updateVManip(v3s16 pos)
+{
+ Mapgen *mg = m_emerge->getCurrentMapgen();
+ if (!mg)
+ return;
+
+ ManualMapVoxelManipulator *vm = mg->vm;
+ if (!vm)
+ return;
+
+ if (!vm->m_area.contains(pos))
+ return;
+
+ s32 idx = vm->m_area.index(pos);
+ vm->m_data[idx] = getNodeNoEx(pos);
+ vm->m_flags[idx] &= ~VOXELFLAG_NO_DATA;
+
+ vm->m_is_dirty = true;
+}
+
s16 ServerMap::findGroundLevel(v2s16 p2d)
{
#if 0
{
DSTACK(__FUNCTION_NAME);
- /*infostream<<"ServerMap::loadMapMeta(): Loading map metadata"
- <<std::endl;*/
-
- std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
+ std::string fullpath = m_savedir + DIR_DELIM "map_meta.txt";
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
- if(is.good() == false)
- {
- infostream<<"ERROR: ServerMap::loadMapMeta(): "
- <<"could not open"<<fullpath<<std::endl;
+ if (!is.good()) {
+ errorstream << "ServerMap::loadMapMeta(): "
+ << "could not open" << fullpath << std::endl;
throw FileNotGoodException("Cannot open map metadata");
}
Settings params;
- for(;;)
- {
- if(is.eof())
- throw SerializationError
- ("ServerMap::loadMapMeta(): [end_of_params] not found");
- std::string line;
- std::getline(is, line);
- std::string trimmedline = trim(line);
- if(trimmedline == "[end_of_params]")
- break;
- params.parseConfigLine(line);
+ if (!params.parseConfigLines(is, "[end_of_params]")) {
+ throw SerializationError("ServerMap::loadMapMeta(): "
+ "[end_of_params] not found!");
}
m_emerge->loadParamsFromSettings(¶ms);
- verbosestream<<"ServerMap::loadMapMeta(): seed="
- << m_emerge->params.seed<<std::endl;
+ verbosestream << "ServerMap::loadMapMeta(): seed="
+ << m_emerge->params.seed << std::endl;
}
void ServerMap::saveSectorMeta(ServerMapSector *sector)
bool ServerMap::saveBlock(MapBlock *block)
{
- return dbase->saveBlock(block);
+ return saveBlock(block, dbase);
+}
+
+bool ServerMap::saveBlock(MapBlock *block, Database *db)
+{
+ v3s16 p3d = block->getPos();
+
+ // Dummy blocks are not written
+ if (block->isDummy()) {
+ errorstream << "WARNING: saveBlock: Not writing dummy block "
+ << PP(p3d) << std::endl;
+ return true;
+ }
+
+ // Format used for writing
+ u8 version = SER_FMT_VER_HIGHEST_WRITE;
+
+ /*
+ [0] u8 serialization version
+ [1] data
+ */
+ std::ostringstream o(std::ios_base::binary);
+ o.write((char*) &version, 1);
+ block->serialize(o, version, true);
+
+ std::string data = o.str();
+ bool ret = db->saveBlock(p3d, data);
+ if(ret) {
+ // We just wrote it to the disk so clear modified flag
+ block->resetModified();
+ }
+ return ret;
}
void ServerMap::loadBlock(std::string sectordir, std::string blockfile,
DSTACK(__FUNCTION_NAME);
std::string fullpath = sectordir+DIR_DELIM+blockfile;
- try{
+ try {
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
v2s16 p2d(blockpos.X, blockpos.Z);
- MapBlock *ret;
+ std::string ret;
ret = dbase->loadBlock(blockpos);
- if (ret) return (ret);
+ if (ret != "") {
+ loadBlock(&ret, blockpos, createSector(p2d), false);
+ return getBlockNoCreateNoEx(blockpos);
+ }
// Not found in database, try the files
// The directory layout we're going to load from.
ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
VoxelManipulator(),
+ m_is_dirty(false),
m_create_area(false),
m_map(map)
{
{
}
+void ManualMapVoxelManipulator::initializeBlank(v3s16 blockpos_min,
+ v3s16 blockpos_max)
+{
+ // Units of these are MapBlocks
+ v3s16 pmin = blockpos_min;
+ v3s16 pmax = blockpos_max;
+
+ VoxelArea block_area_nodes(pmin * MAP_BLOCKSIZE,
+ (pmax + 1) * MAP_BLOCKSIZE - v3s16(1,1,1));
+
+ addArea(block_area_nodes);
+ u32 extent = m_area.getVolume();
+ for (u32 i = 0; i != extent; i++)
+ m_data[i] = MapNode(CONTENT_IGNORE);
+
+ for (s32 z = pmin.Z; z <= pmax.Z; z++)
+ for (s32 y = pmin.Y; y <= pmax.Y; y++)
+ for (s32 x = pmin.X; x <= pmax.X; x++)
+ m_loaded_blocks[v3s16(x, y, z)] = 0;
+
+ m_is_dirty = false;
+}
+
void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min,
- v3s16 blockpos_max, bool load_if_inexistent)
+ v3s16 blockpos_max, bool load_if_inexistent)
{
TimeTaker timer1("initialEmerge", &emerge_time);
m_loaded_blocks[p] = flags;
}
+
+ m_is_dirty = false;
}
void ManualMapVoxelManipulator::blitBackAll(
- std::map<v3s16, MapBlock*> * modified_blocks)
+ std::map<v3s16, MapBlock*> *modified_blocks,
+ bool overwrite_generated)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
v3s16 p = i->first;
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
bool existed = !(i->second & VMANIP_BLOCK_DATA_INEXIST);
- if((existed == false) || (block == NULL))
- {
+ if ((existed == false) || (block == NULL) ||
+ (overwrite_generated == false && block->isGenerated() == true))
continue;
- }
block->copyFrom(*this);
projects / oweals / minetest.git / blobdiff