#include "map.h"
#include "mapsector.h"
#include "mapblock.h"
-#include "main.h"
#include "filesys.h"
#include "voxel.h"
#include "porting.h"
#include "database.h"
#include "database-dummy.h"
#include "database-sqlite3.h"
+#include <deque>
#if USE_LEVELDB
#include "database-leveldb.h"
#endif
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-/*
- SQLite format specification:
- - Initially only replaces sectors/ and sectors2/
-
- If map.sqlite does not exist in the save dir
- or the block was not found in the database
- the map will try to load from sectors folder.
- In either case, map.sqlite will be created
- and all future saves will save there.
-
- Structure of map.sqlite:
- Tables:
- blocks
- (PK) INT pos
- BLOB data
-*/
/*
Map
v3s16 n2pos = pos + dirs[i];
// Get the block where the node is located
- v3s16 blockpos = getNodeBlockPos(n2pos);
+ v3s16 blockpos, relpos;
+ getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
continue;
}
- // 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);
}
/*infostream<<"unspreadLight(): Changed block "
- <<blockchangecount<<" times"
- <<" for "<<from_nodes.size()<<" nodes"
- <<std::endl;*/
+ <<blockchangecount<<" times"
+ <<" for "<<from_nodes.size()<<" nodes"
+ <<std::endl;*/
if(!unlighted_nodes.empty())
unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
- // Cache this a bit, too
+ // Cache this a bit, too
bool block_checked_in_modified = false;
for(std::set<v3s16>::iterator j = from_nodes.begin();
j != from_nodes.end(); ++j)
{
v3s16 pos = *j;
- v3s16 blockpos = getNodeBlockPos(pos);
+ v3s16 blockpos, relpos;
+
+ getNodeBlockPosWithOffset(pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
if(block->isDummy())
continue;
- // Calculate relative position in block
- v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
-
// Get node straight from the block
bool is_valid_position;
MapNode n = block->getNode(relpos, &is_valid_position);
v3s16 n2pos = pos + dirs[i];
// Get the block where the node is located
- v3s16 blockpos = getNodeBlockPos(n2pos);
+ v3s16 blockpos, relpos;
+ getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
// Only fetch a new block if the block position has changed
try {
continue;
}
- // 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)
//bool debug=true;
//u32 count_was = modified_blocks.size();
- std::map<v3s16, MapBlock*> blocks_to_update;
+ //std::map<v3s16, MapBlock*> blocks_to_update;
std::set<v3s16> light_sources;
v3s16 pos = block->getPos();
v3s16 posnodes = block->getPosRelative();
modified_blocks[pos] = block;
- blocks_to_update[pos] = block;
+ //blocks_to_update[pos] = block;
/*
Clear all light from block
}
else
{
- // Invalid lighting bank
- assert(0);
+ assert("Invalid lighting bank" == NULL);
}
/*infostream<<"Bottom for sunlight-propagated block ("
}
catch(InvalidPositionException &e)
{
- assert(0);
+ FATAL_ERROR("Invalid position");
}
}
This also clears the lighting.
*/
- MapNode n;
- n.setContent(replace_material);
+ MapNode n(replace_material);
setNode(p, n);
for(s32 i=0; i<2; i++)
n.setLight(LIGHTBANK_DAY, 0, ndef);
setNode(p, n);
} else {
- assert(0);
+ FATAL_ERROR("Invalid position");
}
}
Updates usage timers
*/
void Map::timerUpdate(float dtime, float unload_timeout,
- std::list<v3s16> *unloaded_blocks)
+ std::vector<v3s16> *unloaded_blocks)
{
bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
// Profile modified reasons
Profiler modprofiler;
- std::list<v2s16> sector_deletion_queue;
+ std::vector<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
u32 block_count_all = 0;
beginSave();
for(std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
- si != m_sectors.end(); ++si)
- {
+ si != m_sectors.end(); ++si) {
MapSector *sector = si->second;
bool all_blocks_deleted = true;
- std::list<MapBlock*> blocks;
+ MapBlockVect blocks;
sector->getBlocks(blocks);
- for(std::list<MapBlock*>::iterator i = blocks.begin();
- i != blocks.end(); ++i)
- {
+ for(MapBlockVect::iterator i = blocks.begin();
+ i != blocks.end(); ++i) {
MapBlock *block = (*i);
block->incrementUsageTimer(dtime);
- if(block->refGet() == 0 && block->getUsageTimer() > unload_timeout)
- {
+ if(block->refGet() == 0 && block->getUsageTimer() > unload_timeout) {
v3s16 p = block->getPos();
// Save if modified
- if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading)
- {
- modprofiler.add(block->getModifiedReason(), 1);
+ if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading) {
+ modprofiler.add(block->getModifiedReasonString(), 1);
if (!saveBlock(block))
continue;
saved_blocks_count++;
deleted_blocks_count++;
}
- else
- {
+ else {
all_blocks_deleted = false;
block_count_all++;
}
}
- if(all_blocks_deleted)
- {
+ if(all_blocks_deleted) {
sector_deletion_queue.push_back(si->first);
}
}
}
}
-void Map::unloadUnreferencedBlocks(std::list<v3s16> *unloaded_blocks)
+void Map::unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks)
{
timerUpdate(0.0, -1.0, unloaded_blocks);
}
-void Map::deleteSectors(std::list<v2s16> &list)
+void Map::deleteSectors(std::vector<v2s16> §orList)
{
- for(std::list<v2s16>::iterator j = list.begin();
- j != list.end(); ++j)
- {
+ for(std::vector<v2s16>::iterator j = sectorList.begin();
+ j != sectorList.end(); ++j) {
MapSector *sector = m_sectors[*j];
// If sector is in sector cache, remove it from there
if(m_sector_cache == sector)
}
}
-#if 0
-void Map::unloadUnusedData(float timeout,
- core::list<v3s16> *deleted_blocks)
-{
- core::list<v2s16> sector_deletion_queue;
- u32 deleted_blocks_count = 0;
- u32 saved_blocks_count = 0;
-
- core::map<v2s16, MapSector*>::Iterator si = m_sectors.getIterator();
- for(; si.atEnd() == false; si++)
- {
- MapSector *sector = si.getNode()->getValue();
-
- bool all_blocks_deleted = true;
-
- core::list<MapBlock*> blocks;
- sector->getBlocks(blocks);
- for(core::list<MapBlock*>::Iterator i = blocks.begin();
- i != blocks.end(); i++)
- {
- MapBlock *block = (*i);
-
- if(block->getUsageTimer() > timeout)
- {
- // Save if modified
- if(block->getModified() != MOD_STATE_CLEAN)
- {
- saveBlock(block);
- saved_blocks_count++;
- }
- // Delete from memory
- sector->deleteBlock(block);
- deleted_blocks_count++;
- }
- else
- {
- all_blocks_deleted = false;
- }
- }
-
- if(all_blocks_deleted)
- {
- sector_deletion_queue.push_back(si.getNode()->getKey());
- }
- }
-
- deleteSectors(sector_deletion_queue);
-
- infostream<<"Map: Unloaded "<<deleted_blocks_count<<" blocks from memory"
- <<", of which "<<saved_blocks_count<<" were wr."
- <<std::endl;
-
- //return sector_deletion_queue.getSize();
- //return deleted_blocks_count;
-}
-#endif
-
void Map::PrintInfo(std::ostream &out)
{
out<<"Map: ";
NeighborType t;
v3s16 p;
bool l; //can liquid
+
+ NodeNeighbor()
+ : n(CONTENT_AIR)
+ { }
+
+ NodeNeighbor(const MapNode &node, NeighborType n_type, v3s16 pos)
+ : n(node),
+ t(n_type),
+ p(pos)
+ { }
};
void Map::transforming_liquid_add(v3s16 p) {
infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
// list of nodes that due to viscosity have not reached their max level height
- UniqueQueue<v3s16> must_reflow;
+ std::deque<v3s16> must_reflow;
// List of MapBlocks that will require a lighting update (due to lava)
std::map<v3s16, MapBlock*> lighting_modified_blocks;
/*
Get a queued transforming liquid node
*/
- v3s16 p0 = m_transforming_liquid.pop_front();
+ v3s16 p0 = m_transforming_liquid.front();
+ m_transforming_liquid.pop_front();
MapNode n0 = getNodeNoEx(p0);
break;
}
v3s16 npos = p0 + dirs[i];
- NodeNeighbor nb = {getNodeNoEx(npos), nt, npos};
+ NodeNeighbor nb(getNodeNoEx(npos), nt, npos);
switch (nodemgr->get(nb.n.getContent()).liquid_type) {
case LIQUID_NONE:
if (nb.n.getContent() == CONTENT_AIR) {
content_t new_node_content;
s8 new_node_level = -1;
s8 max_node_level = -1;
- u8 range = rangelim(nodemgr->get(liquid_kind).liquid_range, 0, LIQUID_LEVEL_MAX+1);
+
+ u8 range = nodemgr->get(liquid_kind).liquid_range;
+ if (range > LIQUID_LEVEL_MAX+1)
+ range = LIQUID_LEVEL_MAX+1;
+
if ((num_sources >= 2 && nodemgr->get(liquid_kind).liquid_renewable) || liquid_type == LIQUID_SOURCE) {
// liquid_kind will be set to either the flowing alternative of the node (if it's a liquid)
// or the flowing alternative of the first of the surrounding sources (if it's air), so
// Find out whether there is a suspect for this action
std::string suspect;
- if(m_gamedef->rollback()){
+ if(m_gamedef->rollback()) {
suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
}
- if(!suspect.empty()){
+ if(m_gamedef->rollback() && !suspect.empty()){
// Blame suspect
RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
// Get old node for rollback
}
}
//infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
- while (must_reflow.size() > 0)
- m_transforming_liquid.push_back(must_reflow.pop_front());
+
+ for (std::deque<v3s16>::iterator iter = must_reflow.begin(); iter != must_reflow.end(); ++iter)
+ m_transforming_liquid.push_back(*iter);
+
updateLighting(lighting_modified_blocks, modified_blocks);
}
}
+std::vector<v3s16> Map::findNodesWithMetadata(v3s16 p1, v3s16 p2)
+{
+ std::vector<v3s16> positions_with_meta;
+
+ sortBoxVerticies(p1, p2);
+ v3s16 bpmin = getNodeBlockPos(p1);
+ v3s16 bpmax = getNodeBlockPos(p2);
+
+ VoxelArea area(p1, p2);
+
+ for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
+ for (s16 y = bpmin.Y; y <= bpmax.Y; y++)
+ for (s16 x = bpmin.X; x <= bpmax.X; x++) {
+ v3s16 blockpos(x, y, z);
+
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if (!block) {
+ verbosestream << "Map::getNodeMetadata(): Need to emerge "
+ << PP(blockpos) << std::endl;
+ block = emergeBlock(blockpos, false);
+ }
+ if (!block) {
+ infostream << "WARNING: Map::getNodeMetadata(): Block not found"
+ << std::endl;
+ continue;
+ }
+
+ v3s16 p_base = blockpos * MAP_BLOCKSIZE;
+ std::vector<v3s16> keys = block->m_node_metadata.getAllKeys();
+ for (size_t i = 0; i != keys.size(); i++) {
+ v3s16 p(keys[i] + p_base);
+ if (!area.contains(p))
+ continue;
+
+ positions_with_meta.push_back(p);
+ }
+ }
+
+ return positions_with_meta;
+}
+
NodeMetadata *Map::getNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
bool succeeded = conf.readConfigFile(conf_path.c_str());
if (!succeeded || !conf.exists("backend")) {
// fall back to sqlite3
- dbase = new Database_SQLite3(this, savedir);
conf.set("backend", "sqlite3");
- } else {
- std::string backend = conf.get("backend");
- if (backend == "dummy")
- dbase = new Database_Dummy(this);
- else if (backend == "sqlite3")
- dbase = new Database_SQLite3(this, savedir);
- #if USE_LEVELDB
- else if (backend == "leveldb")
- dbase = new Database_LevelDB(this, savedir);
- #endif
- #if USE_REDIS
- else if (backend == "redis")
- dbase = new Database_Redis(this, savedir);
- #endif
- else
- throw BaseException("Unknown map backend");
}
+ std::string backend = conf.get("backend");
+ dbase = createDatabase(backend, savedir, conf);
+
+ if (!conf.updateConfigFile(conf_path.c_str()))
+ errorstream << "ServerMap::ServerMap(): Failed to update world.mt!" << std::endl;
m_savedir = savedir;
m_map_saving_enabled = false;
v2s16 sectorpos(x, z);
// Sector metadata is loaded from disk if not already loaded.
ServerMapSector *sector = createSector(sectorpos);
- assert(sector);
+ FATAL_ERROR_IF(sector == NULL, "createSector() failed");
(void) sector;
for(s16 y=blockpos_min.Y-extra_borders.Y;
v3s16 bigarea_blocks_min = blockpos_min - extra_borders;
v3s16 bigarea_blocks_max = blockpos_max + extra_borders;
- data->vmanip = new ManualMapVoxelManipulator(this);
+ data->vmanip = new MMVManip(this);
//data->vmanip->setMap(this);
// Add the area
{
//TimeTaker timer("initBlockMake() initialEmerge");
- data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max, false);
+ data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
}
// Ensure none of the blocks to be generated were marked as containing CONTENT_IGNORE
*/
while(data->transforming_liquid.size() > 0)
{
- v3s16 p = data->transforming_liquid.pop_front();
- m_transforming_liquid.push_back(p);
+ m_transforming_liquid.push_back(data->transforming_liquid.front());
+ data->transforming_liquid.pop_front();
}
/*
Set block as modified
*/
block->raiseModified(MOD_STATE_WRITE_NEEDED,
- "finishBlockMake expireDayNightDiff");
+ MOD_REASON_EXPIRE_DAYNIGHTDIFF);
}
/*
lighting on blocks for them.
*/
ServerMapSector *sector;
- try{
+ try {
sector = (ServerMapSector*)createSector(p2d);
assert(sector->getId() == MAPSECTOR_SERVER);
}
if (!mg)
return;
- ManualMapVoxelManipulator *vm = mg->vm;
+ MMVManip *vm = mg->vm;
if (!vm)
return;
}
bool ServerMap::loadFromFolders() {
- if(!dbase->Initialized() && !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite")) // ?
+ if (!dbase->initialized() &&
+ !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
return true;
return false;
}
{
case 1:
snprintf(cc, 9, "%.4x%.4x",
- (unsigned int)pos.X&0xffff,
- (unsigned int)pos.Y&0xffff);
+ (unsigned int) pos.X & 0xffff,
+ (unsigned int) pos.Y & 0xffff);
return m_savedir + DIR_DELIM + "sectors" + DIR_DELIM + cc;
case 2:
- snprintf(cc, 9, "%.3x" DIR_DELIM "%.3x",
- (unsigned int)pos.X&0xfff,
- (unsigned int)pos.Y&0xfff);
+ snprintf(cc, 9, (std::string("%.3x") + DIR_DELIM + "%.3x").c_str(),
+ (unsigned int) pos.X & 0xfff,
+ (unsigned int) pos.Y & 0xfff);
return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
default:
{
// New layout
fs::RemoveLastPathComponent(dirname, &component, 2);
- r = sscanf(component.c_str(), "%3x" DIR_DELIM "%3x", &x, &y);
+ r = sscanf(component.c_str(), (std::string("%3x") + DIR_DELIM + "%3x").c_str(), &x, &y);
// Sign-extend the 12 bit values up to 16 bits...
- if(x&0x800) x|=0xF000;
- if(y&0x800) y|=0xF000;
+ if(x & 0x800) x |= 0xF000;
+ if(y & 0x800) y |= 0xF000;
}
else
{
- assert(false);
+ r = -1;
}
- assert(r == 2);
+
+ FATAL_ERROR_IF(r != 2, "getSectorPos()");
v2s16 pos((s16)x, (s16)y);
return pos;
}
void ServerMap::save(ModifiedState save_level)
{
DSTACK(__FUNCTION_NAME);
- if(m_map_saving_enabled == false)
- {
+ if(m_map_saving_enabled == false) {
infostream<<"WARNING: Not saving map, saving disabled."<<std::endl;
return;
}
infostream<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
- if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN)
- {
+ if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
saveMapMeta();
}
bool save_started = false;
for(std::map<v2s16, MapSector*>::iterator i = m_sectors.begin();
- i != m_sectors.end(); ++i)
- {
+ i != m_sectors.end(); ++i) {
ServerMapSector *sector = (ServerMapSector*)i->second;
assert(sector->getId() == MAPSECTOR_SERVER);
- if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN)
- {
+ if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN) {
saveSectorMeta(sector);
sector_meta_count++;
}
- std::list<MapBlock*> blocks;
+
+ MapBlockVect blocks;
sector->getBlocks(blocks);
- for(std::list<MapBlock*>::iterator j = blocks.begin();
- j != blocks.end(); ++j)
- {
+ for(MapBlockVect::iterator j = blocks.begin();
+ j != blocks.end(); ++j) {
MapBlock *block = *j;
block_count_all++;
- if(block->getModified() >= (u32)save_level)
- {
+ if(block->getModified() >= (u32)save_level) {
// Lazy beginSave()
- if(!save_started){
+ if(!save_started) {
beginSave();
save_started = true;
}
- modprofiler.add(block->getModifiedReason(), 1);
+ modprofiler.add(block->getModifiedReasonString(), 1);
saveBlock(block);
block_count++;
}
}
}
+
if(save_started)
endSave();
Only print if something happened or saved whole map
*/
if(save_level == MOD_STATE_CLEAN || sector_meta_count != 0
- || block_count != 0)
- {
+ || block_count != 0) {
infostream<<"ServerMap: Written: "
<<sector_meta_count<<" sector metadata files, "
<<block_count<<" block files"
}
}
-void ServerMap::listAllLoadableBlocks(std::list<v3s16> &dst)
+void ServerMap::listAllLoadableBlocks(std::vector<v3s16> &dst)
{
- if(loadFromFolders()){
- errorstream<<"Map::listAllLoadableBlocks(): Result will be missing "
- <<"all blocks that are stored in flat files"<<std::endl;
+ if (loadFromFolders()) {
+ errorstream << "Map::listAllLoadableBlocks(): Result will be missing "
+ << "all blocks that are stored in flat files." << std::endl;
}
dbase->listAllLoadableBlocks(dst);
}
-void ServerMap::listAllLoadedBlocks(std::list<v3s16> &dst)
+void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
{
for(std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
si != m_sectors.end(); ++si)
{
MapSector *sector = si->second;
- std::list<MapBlock*> blocks;
+ MapBlockVect blocks;
sector->getBlocks(blocks);
- for(std::list<MapBlock*>::iterator i = blocks.begin();
- i != blocks.end(); ++i)
- {
- MapBlock *block = (*i);
- v3s16 p = block->getPos();
+ for(MapBlockVect::iterator i = blocks.begin();
+ i != blocks.end(); ++i) {
+ v3s16 p = (*i)->getPos();
dst.push_back(p);
}
}
{
DSTACK(__FUNCTION_NAME);
- /*infostream<<"ServerMap::saveMapMeta(): "
- <<"seed="<<m_seed
- <<std::endl;*/
-
createDirs(m_savedir);
std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
- std::ostringstream ss(std::ios_base::binary);
-
- Settings params;
+ std::ostringstream oss(std::ios_base::binary);
+ Settings conf;
- m_emerge->saveParamsToSettings(¶ms);
- params.writeLines(ss);
+ m_emerge->params.save(conf);
+ conf.writeLines(oss);
- ss<<"[end_of_params]\n";
+ oss << "[end_of_params]\n";
- if(!fs::safeWriteToFile(fullpath, ss.str()))
- {
- infostream<<"ERROR: ServerMap::saveMapMeta(): "
- <<"could not write "<<fullpath<<std::endl;
+ if(!fs::safeWriteToFile(fullpath, oss.str())) {
+ errorstream << "ServerMap::saveMapMeta(): "
+ << "could not write " << fullpath << std::endl;
throw FileNotGoodException("Cannot save chunk metadata");
}
{
DSTACK(__FUNCTION_NAME);
- std::string fullpath = m_savedir + DIR_DELIM "map_meta.txt";
+ Settings conf;
+ std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
+
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if (!is.good()) {
errorstream << "ServerMap::loadMapMeta(): "
- << "could not open" << fullpath << std::endl;
+ "could not open " << fullpath << std::endl;
throw FileNotGoodException("Cannot open map metadata");
}
- Settings params;
-
- if (!params.parseConfigLines(is, "[end_of_params]")) {
+ if (!conf.parseConfigLines(is, "[end_of_params]")) {
throw SerializationError("ServerMap::loadMapMeta(): "
"[end_of_params] not found!");
}
- m_emerge->loadParamsFromSettings(¶ms);
+ m_emerge->params.load(conf);
verbosestream << "ServerMap::loadMapMeta(): seed="
<< m_emerge->params.seed << std::endl;
{
DSTACK(__FUNCTION_NAME);
- MapSector *sector = NULL;
-
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
// 2 - new sectors2/xxx/zzz/
}
try{
- sector = loadSectorMeta(sectordir, loadlayout != 2);
+ loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
}
#endif
+Database *ServerMap::createDatabase(const std::string &name, const std::string &savedir, Settings &conf)
+{
+ if (name == "sqlite3")
+ return new Database_SQLite3(savedir);
+ if (name == "dummy")
+ return new Database_Dummy();
+ #if USE_LEVELDB
+ else if (name == "leveldb")
+ return new Database_LevelDB(savedir);
+ #endif
+ #if USE_REDIS
+ else if (name == "redis")
+ return new Database_Redis(conf);
+ #endif
+ else
+ throw BaseException(std::string("Database backend ") + name + " not supported.");
+}
+
void ServerMap::beginSave()
{
dbase->beginSave();
std::string data = o.str();
bool ret = db->saveBlock(p3d, data);
- if(ret) {
+ if (ret) {
// We just wrote it to the disk so clear modified flag
block->resetModified();
}
{
DSTACK(__FUNCTION_NAME);
- std::string fullpath = sectordir+DIR_DELIM+blockfile;
+ std::string fullpath = sectordir + DIR_DELIM + blockfile;
try {
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
<<"what()="<<e.what()
<<std::endl;
// Ignoring. A new one will be generated.
- assert(0);
+ abort();
// TODO: Backup file; name is in fullpath.
}
<<"(ignore_world_load_errors)"<<std::endl;
} else {
throw SerializationError("Invalid block data in database");
- //assert(0);
}
}
}
*/
std::string blockfilename = getBlockFilename(blockpos);
- if(fs::PathExists(sectordir+DIR_DELIM+blockfilename) == false)
+ if(fs::PathExists(sectordir + DIR_DELIM + blockfilename) == false)
return NULL;
/*
return getBlockNoCreateNoEx(blockpos);
}
+bool ServerMap::deleteBlock(v3s16 blockpos)
+{
+ if (!dbase->deleteBlock(blockpos))
+ return false;
+
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if (block) {
+ v2s16 p2d(blockpos.X, blockpos.Z);
+ MapSector *sector = getSectorNoGenerateNoEx(p2d);
+ if (!sector)
+ return false;
+ sector->deleteBlock(block);
+ }
+
+ return true;
+}
+
void ServerMap::PrintInfo(std::ostream &out)
{
out<<"ServerMap: ";
}
-ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
+MMVManip::MMVManip(Map *map):
VoxelManipulator(),
m_is_dirty(false),
m_create_area(false),
{
}
-ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
+MMVManip::~MMVManip()
{
}
-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)
+void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
+ bool load_if_inexistent)
{
TimeTaker timer1("initialEmerge", &emerge_time);
block = svrmap->emergeBlock(p, false);
if (block == NULL)
block = svrmap->createBlock(p);
- else
- block->copyTo(*this);
+ block->copyTo(*this);
} else {
flags |= VMANIP_BLOCK_DATA_INEXIST;
m_is_dirty = false;
}
-void ManualMapVoxelManipulator::blitBackAll(
- std::map<v3s16, MapBlock*> *modified_blocks,
- bool overwrite_generated)
+void MMVManip::blitBackAll(std::map<v3s16, MapBlock*> *modified_blocks,
+ bool overwrite_generated)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;