#include "database.h"
#include "database-dummy.h"
#include "database-sqlite3.h"
+#include <deque>
#if USE_LEVELDB
#include "database-leveldb.h"
#endif
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
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++)
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);
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)
- {
+ if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading) {
modprofiler.add(block->getModifiedReason(), 1);
if (!saveBlock(block))
continue;
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);
}
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) {
// 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);
*/
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();
}
/*
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;
}
}
}
}
+
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 "
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);
}
}
createDirs(m_savedir);
- std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
+ std::string fullpath = m_savedir + DIR_DELIM "map_meta.txt";
std::ostringstream ss(std::ios_base::binary);
Settings params;
{
DSTACK(__FUNCTION_NAME);
+ Settings params;
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;
- throw FileNotGoodException("Cannot open map metadata");
- }
- Settings params;
+ if (fs::PathExists(fullpath)) {
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if (!is.good()) {
+ errorstream << "ServerMap::loadMapMeta(): "
+ "could not open " << fullpath << std::endl;
+ throw FileNotGoodException("Cannot open map metadata");
+ }
- if (!params.parseConfigLines(is, "[end_of_params]")) {
- throw SerializationError("ServerMap::loadMapMeta(): "
+ if (!params.parseConfigLines(is, "[end_of_params]")) {
+ throw SerializationError("ServerMap::loadMapMeta(): "
"[end_of_params] not found!");
+ }
}
m_emerge->loadParamsFromSettings(¶ms);
{
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)
{
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: ";
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;
projects / dragonfireclient.git / blobdiff