/*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
#include "filesys.h"
#include "voxel.h"
#include "porting.h"
-#include "mapgen.h"
+#include "serialization.h"
#include "nodemetadata.h"
#include "settings.h"
#include "log.h"
#include "nodedef.h"
#include "gamedef.h"
#include "util/directiontables.h"
+#include "util/mathconstants.h"
#include "rollback_interface.h"
+#include "environment.h"
+#include "emerge.h"
#include "mapgen_v6.h"
+#include "biome.h"
+#include "config.h"
+#include "server.h"
+#include "database.h"
+#include "database-dummy.h"
+#include "database-sqlite3.h"
+#if USE_LEVELDB
+#include "database-leveldb.h"
+#endif
+#if USE_REDIS
+#include "database-redis.h"
+#endif
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
m_gamedef(gamedef),
m_sector_cache(NULL)
{
- /*m_sector_mutex.Init();
- assert(m_sector_mutex.IsInitialized());*/
}
Map::~Map()
/*
Free all MapSectors
*/
- core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
- for(; i.atEnd() == false; i++)
+ for(std::map<v2s16, MapSector*>::iterator i = m_sectors.begin();
+ i != m_sectors.end(); ++i)
{
- MapSector *sector = i.getNode()->getValue();
- delete sector;
+ delete i->second;
}
}
void Map::addEventReceiver(MapEventReceiver *event_receiver)
{
- m_event_receivers.insert(event_receiver, false);
+ m_event_receivers.insert(event_receiver);
}
void Map::removeEventReceiver(MapEventReceiver *event_receiver)
{
- if(m_event_receivers.find(event_receiver) == NULL)
- return;
- m_event_receivers.remove(event_receiver);
+ m_event_receivers.erase(event_receiver);
}
void Map::dispatchEvent(MapEditEvent *event)
{
- for(core::map<MapEventReceiver*, bool>::Iterator
- i = m_event_receivers.getIterator();
- i.atEnd()==false; i++)
+ for(std::set<MapEventReceiver*>::iterator
+ i = m_event_receivers.begin();
+ i != m_event_receivers.end(); ++i)
{
- MapEventReceiver* event_receiver = i.getNode()->getKey();
- event_receiver->onMapEditEvent(event);
+ (*i)->onMapEditEvent(event);
}
}
return sector;
}
- core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
+ std::map<v2s16, MapSector*>::iterator n = m_sectors.find(p);
- if(n == NULL)
+ if(n == m_sectors.end())
return NULL;
- MapSector *sector = n->getValue();
+ MapSector *sector = n->second;
// Cache the last result
m_sector_cache_p = p;
values of from_nodes are lighting values.
*/
void Map::unspreadLight(enum LightBank bank,
- core::map<v3s16, u8> & from_nodes,
- core::map<v3s16, bool> & light_sources,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::map<v3s16, u8> & from_nodes,
+ std::set<v3s16> & light_sources,
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
u32 blockchangecount = 0;
- core::map<v3s16, u8> unlighted_nodes;
- core::map<v3s16, u8>::Iterator j;
- j = from_nodes.getIterator();
+ std::map<v3s16, u8> unlighted_nodes;
/*
Initialize block cache
// Cache this a bit, too
bool block_checked_in_modified = false;
- for(; j.atEnd() == false; j++)
+ for(std::map<v3s16, u8>::iterator j = from_nodes.begin();
+ j != from_nodes.end(); ++j)
{
- v3s16 pos = j.getNode()->getKey();
+ v3s16 pos = j->first;
v3s16 blockpos = getNodeBlockPos(pos);
// Only fetch a new block if the block position has changed
continue;
// Calculate relative position in block
- v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
+ //v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
// Get node straight from the block
- MapNode n = block->getNode(relpos);
+ //MapNode n = block->getNode(relpos);
- u8 oldlight = j.getNode()->getValue();
+ u8 oldlight = j->second;
// Loop through 6 neighbors
for(u16 i=0; i<6; i++)
n2.setLight(bank, 0, nodemgr);
block->setNode(relpos, n2);
- unlighted_nodes.insert(n2pos, current_light);
+ unlighted_nodes[n2pos] = current_light;
changed = true;
/*
light_sources.remove(n2pos);*/
}
else{
- light_sources.insert(n2pos, true);
+ light_sources.insert(n2pos);
}
// 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) == NULL)
+ if(modified_blocks.find(blockpos) == modified_blocks.end())
{
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
}
block_checked_in_modified = true;
}
*/
void Map::unLightNeighbors(enum LightBank bank,
v3s16 pos, u8 lightwas,
- core::map<v3s16, bool> & light_sources,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::set<v3s16> & light_sources,
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
- core::map<v3s16, u8> from_nodes;
- from_nodes.insert(pos, lightwas);
+ std::map<v3s16, u8> from_nodes;
+ from_nodes[pos] = lightwas;
unspreadLight(bank, from_nodes, light_sources, modified_blocks);
}
goes on recursively.
*/
void Map::spreadLight(enum LightBank bank,
- core::map<v3s16, bool> & from_nodes,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::set<v3s16> & from_nodes,
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
u32 blockchangecount = 0;
- core::map<v3s16, bool> lighted_nodes;
- core::map<v3s16, bool>::Iterator j;
- j = from_nodes.getIterator();
+ std::set<v3s16> lighted_nodes;
/*
Initialize block cache
// Cache this a bit, too
bool block_checked_in_modified = false;
- for(; j.atEnd() == false; j++)
- //for(; j != from_nodes.end(); j++)
+ for(std::set<v3s16>::iterator j = from_nodes.begin();
+ j != from_nodes.end(); ++j)
{
- v3s16 pos = j.getNode()->getKey();
- //v3s16 pos = *j;
- //infostream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
+ v3s16 pos = *j;
v3s16 blockpos = getNodeBlockPos(pos);
// Only fetch a new block if the block position has changed
*/
if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
{
- lighted_nodes.insert(n2pos, true);
- //lighted_nodes.push_back(n2pos);
+ lighted_nodes.insert(n2pos);
changed = true;
}
/*
{
n2.setLight(bank, newlight, nodemgr);
block->setNode(relpos, n2);
- lighted_nodes.insert(n2pos, true);
- //lighted_nodes.push_back(n2pos);
+ lighted_nodes.insert(n2pos);
changed = true;
}
}
if(changed == true && block_checked_in_modified == false)
{
// If the block is not found in modified_blocks, add.
- if(modified_blocks.find(blockpos) == NULL)
+ if(modified_blocks.find(blockpos) == modified_blocks.end())
{
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
}
block_checked_in_modified = true;
}
*/
void Map::lightNeighbors(enum LightBank bank,
v3s16 pos,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
- core::map<v3s16, bool> from_nodes;
- from_nodes.insert(pos, true);
+ std::set<v3s16> from_nodes;
+ from_nodes.insert(pos);
spreadLight(bank, from_nodes, modified_blocks);
}
Mud is turned into grass in where the sunlight stops.
*/
s16 Map::propagateSunlight(v3s16 start,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
n.setLight(LIGHTBANK_DAY, LIGHT_SUN, nodemgr);
block->setNode(relpos, n);
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
}
else
{
}
void Map::updateLighting(enum LightBank bank,
- core::map<v3s16, MapBlock*> & a_blocks,
- core::map<v3s16, MapBlock*> & modified_blocks)
+ std::map<v3s16, MapBlock*> & a_blocks,
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
//bool debug=true;
//u32 count_was = modified_blocks.size();
- core::map<v3s16, MapBlock*> blocks_to_update;
+ std::map<v3s16, MapBlock*> blocks_to_update;
- core::map<v3s16, bool> light_sources;
+ std::set<v3s16> light_sources;
- core::map<v3s16, u8> unlight_from;
+ std::map<v3s16, u8> unlight_from;
int num_bottom_invalid = 0;
{
//TimeTaker t("first stuff");
- core::map<v3s16, MapBlock*>::Iterator i;
- i = a_blocks.getIterator();
- for(; i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator i = a_blocks.begin();
+ i != a_blocks.end(); ++i)
{
- MapBlock *block = i.getNode()->getValue();
+ MapBlock *block = i->second;
for(;;)
{
v3s16 pos = block->getPos();
v3s16 posnodes = block->getPosRelative();
- modified_blocks.insert(pos, block);
-
- blocks_to_update.insert(pos, block);
+ modified_blocks[pos] = block;
+ blocks_to_update[pos] = block;
/*
Clear all light from block
// If node sources light, add to list
u8 source = nodemgr->get(n).light_source;
if(source != 0)
- light_sources[p + posnodes] = true;
+ light_sources.insert(p + posnodes);
// Collect borders for unlighting
if((x==0 || x == MAP_BLOCKSIZE-1
&& oldlight != 0)
{
v3s16 p_map = p + posnodes;
- unlight_from.insert(p_map, oldlight);
+ unlight_from[p_map] = oldlight;
}
}
catch(InvalidPositionException &e)
//m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
}
-void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
- core::map<v3s16, MapBlock*> & modified_blocks)
+void Map::updateLighting(std::map<v3s16, MapBlock*> & a_blocks,
+ std::map<v3s16, MapBlock*> & modified_blocks)
{
updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks);
updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks);
/*
Update information about whether day and night light differ
*/
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- MapBlock *block = i.getNode()->getValue();
+ MapBlock *block = i->second;
block->expireDayNightDiff();
}
}
/*
*/
void Map::addNodeAndUpdate(v3s16 p, MapNode n,
- core::map<v3s16, MapBlock*> &modified_blocks)
+ std::map<v3s16, MapBlock*> &modified_blocks,
+ bool remove_metadata)
{
INodeDefManager *ndef = m_gamedef->ndef();
*/
v3s16 toppos = p + v3s16(0,1,0);
- v3s16 bottompos = p + v3s16(0,-1,0);
+ //v3s16 bottompos = p + v3s16(0,-1,0);
bool node_under_sunlight = true;
- core::map<v3s16, bool> light_sources;
+ std::set<v3s16> light_sources;
/*
Collect old node for rollback
v3s16 blockpos = getNodeBlockPos(p);
MapBlock * block = getBlockNoCreate(blockpos);
assert(block != NULL);
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
assert(isValidPosition(p));
/*
Remove node metadata
*/
-
- removeNodeMetadata(p);
+ if (remove_metadata) {
+ removeNodeMetadata(p);
+ }
/*
Set the node on the map
/*
Update information about whether day and night light differ
*/
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- MapBlock *block = i.getNode()->getValue();
- block->expireDayNightDiff();
+ i->second->expireDayNightDiff();
}
/*
/*
*/
void Map::removeNodeAndUpdate(v3s16 p,
- core::map<v3s16, MapBlock*> &modified_blocks)
+ std::map<v3s16, MapBlock*> &modified_blocks)
{
INodeDefManager *ndef = m_gamedef->ndef();
{
}
- core::map<v3s16, bool> light_sources;
+ std::set<v3s16> light_sources;
enum LightBank banks[] =
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock * block = getBlockNoCreate(blockpos);
assert(block != NULL);
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
/*
If the removed node was under sunlight, propagate the
// Get the brightest neighbour node and propagate light from it
v3s16 n2p = getBrightestNeighbour(bank, p);
try{
- MapNode n2 = getNode(n2p);
+ //MapNode n2 = getNode(n2p);
lightNeighbors(bank, n2p, modified_blocks);
}
catch(InvalidPositionException &e)
/*
Update information about whether day and night light differ
*/
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- MapBlock *block = i.getNode()->getValue();
- block->expireDayNightDiff();
+ i->second->expireDayNightDiff();
}
/*
}
}
-bool Map::addNodeWithEvent(v3s16 p, MapNode n)
+bool Map::addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata)
{
MapEditEvent event;
- event.type = MEET_ADDNODE;
+ event.type = remove_metadata ? MEET_ADDNODE : MEET_SWAPNODE;
event.p = p;
event.n = n;
bool succeeded = true;
try{
- core::map<v3s16, MapBlock*> modified_blocks;
- addNodeAndUpdate(p, n, modified_blocks);
+ std::map<v3s16, MapBlock*> modified_blocks;
+ addNodeAndUpdate(p, n, modified_blocks, remove_metadata);
// Copy modified_blocks to event
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd()==false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- event.modified_blocks.insert(i.getNode()->getKey(), false);
+ event.modified_blocks.insert(i->first);
}
}
catch(InvalidPositionException &e){
bool succeeded = true;
try{
- core::map<v3s16, MapBlock*> modified_blocks;
+ std::map<v3s16, MapBlock*> modified_blocks;
removeNodeAndUpdate(p, modified_blocks);
// Copy modified_blocks to event
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd()==false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- event.modified_blocks.insert(i.getNode()->getKey(), false);
+ event.modified_blocks.insert(i->first);
}
}
catch(InvalidPositionException &e){
Updates usage timers
*/
void Map::timerUpdate(float dtime, float unload_timeout,
- core::list<v3s16> *unloaded_blocks)
+ std::list<v3s16> *unloaded_blocks)
{
bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
// Profile modified reasons
Profiler modprofiler;
- core::list<v2s16> sector_deletion_queue;
+ std::list<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
u32 block_count_all = 0;
- core::map<v2s16, MapSector*>::Iterator si;
-
beginSave();
- si = m_sectors.getIterator();
- for(; si.atEnd() == false; si++)
+ for(std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
+ si != m_sectors.end(); ++si)
{
- MapSector *sector = si.getNode()->getValue();
+ MapSector *sector = si->second;
bool all_blocks_deleted = true;
- core::list<MapBlock*> blocks;
+ std::list<MapBlock*> blocks;
sector->getBlocks(blocks);
- for(core::list<MapBlock*>::Iterator i = blocks.begin();
- i != blocks.end(); i++)
+ for(std::list<MapBlock*>::iterator i = blocks.begin();
+ i != blocks.end(); ++i)
{
MapBlock *block = (*i);
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);
- saveBlock(block);
+ if (!saveBlock(block))
+ continue;
saved_blocks_count++;
}
if(all_blocks_deleted)
{
- sector_deletion_queue.push_back(si.getNode()->getKey());
+ sector_deletion_queue.push_back(si->first);
}
}
endSave();
}
}
-void Map::deleteSectors(core::list<v2s16> &list)
+void Map::unloadUnreferencedBlocks(std::list<v3s16> *unloaded_blocks)
+{
+ timerUpdate(0.0, -1.0, unloaded_blocks);
+}
+
+void Map::deleteSectors(std::list<v2s16> &list)
{
- core::list<v2s16>::Iterator j;
- for(j=list.begin(); j!=list.end(); j++)
+ for(std::list<v2s16>::iterator j = list.begin();
+ j != list.end(); ++j)
{
MapSector *sector = m_sectors[*j];
// If sector is in sector cache, remove it from there
if(m_sector_cache == sector)
m_sector_cache = NULL;
// Remove from map and delete
- m_sectors.remove(*j);
+ m_sectors.erase(*j);
delete sector;
}
}
MapNode n;
NeighborType t;
v3s16 p;
+ bool l; //can liquid
};
-void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
+void Map::transforming_liquid_add(v3s16 p) {
+ m_transforming_liquid.push_back(p);
+}
+
+s32 Map::transforming_liquid_size() {
+ return m_transforming_liquid.size();
+}
+
+void Map::transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks)
{
INodeDefManager *nodemgr = m_gamedef->ndef();
UniqueQueue<v3s16> must_reflow;
// List of MapBlocks that will require a lighting update (due to lava)
- core::map<v3s16, MapBlock*> lighting_modified_blocks;
+ std::map<v3s16, MapBlock*> lighting_modified_blocks;
+
+ u16 loop_max = g_settings->getU16("liquid_loop_max");
while(m_transforming_liquid.size() != 0)
{
// This should be done here so that it is done when continue is used
- if(loopcount >= initial_size || loopcount >= 10000)
+ if(loopcount >= initial_size || loopcount >= loop_max)
break;
loopcount++;
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);
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
// liquid_kind is set properly, see above
new_node_content = liquid_kind;
max_node_level = new_node_level = LIQUID_LEVEL_MAX;
+ if (new_node_level < (LIQUID_LEVEL_MAX+1-range))
+ new_node_content = CONTENT_AIR;
} else {
// no surrounding sources, so get the maximum level that can flow into this node
for (u16 i = 0; i < num_flows; i++) {
} else
new_node_level = max_node_level;
- if (new_node_level >= 0)
+ if (max_node_level >= (LIQUID_LEVEL_MAX+1-range))
new_node_content = liquid_kind;
else
new_node_content = CONTENT_AIR;
/*
update the current node
*/
+ MapNode n00 = n0;
//bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) {
// set level to last 3 bits, flowing down bit to 4th bit
v3s16 blockpos = getNodeBlockPos(p0);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block != NULL) {
- modified_blocks.insert(blockpos, block);
- // If node emits light, MapBlock requires lighting update
- if(nodemgr->get(n0).light_source != 0)
+ modified_blocks[blockpos] = block;
+ // If new or old node emits light, MapBlock requires lighting update
+ if(nodemgr->get(n0).light_source != 0 ||
+ nodemgr->get(n00).light_source != 0)
lighting_modified_blocks[block->getPos()] = block;
}
updateLighting(lighting_modified_blocks, modified_blocks);
}
-NodeMetadata* Map::getNodeMetadata(v3s16 p)
+NodeMetadata *Map::getNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
- if(!block)
- {
+ if(!block){
infostream<<"WARNING: Map::getNodeMetadata(): Block not found"
<<std::endl;
return NULL;
return meta;
}
-void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
+bool Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
- if(!block)
- {
+ if(!block){
infostream<<"WARNING: Map::setNodeMetadata(): Block not found"
<<std::endl;
- return;
+ return false;
}
block->m_node_metadata.set(p_rel, meta);
+ return true;
}
void Map::removeNodeMetadata(v3s16 p)
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
- if(!block)
- {
+ if(!block){
infostream<<"WARNING: Map::getNodeTimer(): Block not found"
<<std::endl;
return NodeTimer();
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
- if(!block)
- {
+ if(!block){
infostream<<"WARNING: Map::setNodeTimer(): Block not found"
<<std::endl;
return;
*/
ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge):
Map(dout_server, gamedef),
- m_seed(0),
- m_map_metadata_changed(true),
- m_database(NULL),
- m_database_read(NULL),
- m_database_write(NULL)
+ m_emerge(emerge),
+ m_map_metadata_changed(true)
{
verbosestream<<__FUNCTION_NAME<<std::endl;
- m_emerge = emerge;
- m_mgparams = m_emerge->getParamsFromSettings(g_settings);
- if (!m_mgparams)
- m_mgparams = new MapgenV6Params();
-
- m_seed = m_mgparams->seed;
-
- if (g_settings->get("fixed_map_seed").empty())
- {
- m_seed = (((u64)(myrand() & 0xffff) << 0)
- | ((u64)(myrand() & 0xffff) << 16)
- | ((u64)(myrand() & 0xffff) << 32)
- | ((u64)(myrand() & 0xffff) << 48));
- m_mgparams->seed = m_seed;
- }
-
/*
- Experimental and debug stuff
+ Try to load map; if not found, create a new one.
*/
- {
+ // Determine which database backend to use
+ std::string conf_path = savedir + DIR_DELIM + "world.mt";
+ Settings conf;
+ 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");
}
- /*
- Try to load map; if not found, create a new one.
- */
-
m_savedir = savedir;
m_map_saving_enabled = false;
infostream<<"ServerMap: Successfully loaded map "
<<"metadata from "<<savedir
<<", assuming valid save directory."
- <<" seed="<<m_seed<<"."
+ <<" seed="<< m_emerge->params.seed <<"."
<<std::endl;
m_map_saving_enabled = true;
/*
Close database if it was opened
*/
- if(m_database_read)
- sqlite3_finalize(m_database_read);
- if(m_database_write)
- sqlite3_finalize(m_database_write);
- if(m_database)
- sqlite3_close(m_database);
+ delete dbase;
#if 0
/*
#endif
}
-void ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
+u64 ServerMap::getSeed()
{
- bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
- if(enable_mapgen_debug_info)
- infostream<<"initBlockMake(): "
- <<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<") - "
- <<"("<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z<<")"
- <<std::endl;
+ return m_emerge->params.seed;
+}
+
+s16 ServerMap::getWaterLevel()
+{
+ return m_emerge->params.water_level;
+}
- //s16 chunksize = 3;
- //v3s16 chunk_offset(-1,-1,-1);
- //s16 chunksize = 4;
- //v3s16 chunk_offset(-1,-1,-1);
- s16 chunksize = 5;
- v3s16 chunk_offset(-2,-2,-2);
+bool ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
+{
+ bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
+ EMERGE_DBG_OUT("initBlockMake(): " PP(blockpos) " - " PP(blockpos));
+
+ s16 chunksize = m_emerge->params.chunksize;
+ s16 coffset = -chunksize / 2;
+ v3s16 chunk_offset(coffset, coffset, coffset);
v3s16 blockpos_div = getContainerPos(blockpos - chunk_offset, chunksize);
v3s16 blockpos_min = blockpos_div * chunksize;
v3s16 blockpos_max = blockpos_div * chunksize + v3s16(1,1,1)*(chunksize-1);
blockpos_min += chunk_offset;
blockpos_max += chunk_offset;
- //v3s16 extra_borders(1,1,1);
v3s16 extra_borders(1,1,1);
// Do nothing if not inside limits (+-1 because of neighbors)
if(blockpos_over_limit(blockpos_min - extra_borders) ||
blockpos_over_limit(blockpos_max + extra_borders))
- {
- data->no_op = true;
- return;
- }
+ return false;
- data->no_op = false;
- data->seed = m_seed;
+ data->seed = m_emerge->params.seed;
data->blockpos_min = blockpos_min;
data->blockpos_max = blockpos_max;
data->blockpos_requested = blockpos;
// Sector metadata is loaded from disk if not already loaded.
ServerMapSector *sector = createSector(sectorpos);
assert(sector);
+ (void) sector;
for(s16 y=blockpos_min.Y-extra_borders.Y;
y<=blockpos_max.Y+extra_borders.Y; y++)
// Add the area
{
//TimeTaker timer("initBlockMake() initialEmerge");
- data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
+ data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max, false);
}
+ // Ensure none of the blocks to be generated were marked as containing CONTENT_IGNORE
+/* for (s16 z = blockpos_min.Z; z <= blockpos_max.Z; z++) {
+ for (s16 y = blockpos_min.Y; y <= blockpos_max.Y; y++) {
+ for (s16 x = blockpos_min.X; x <= blockpos_max.X; x++) {
+ core::map<v3s16, u8>::Node *n;
+ n = data->vmanip->m_loaded_blocks.find(v3s16(x, y, z));
+ if (n == NULL)
+ continue;
+ u8 flags = n->getValue();
+ flags &= ~VMANIP_BLOCK_CONTAINS_CIGNORE;
+ n->setValue(flags);
+ }
+ }
+ }*/
+
// Data is ready now.
+ return true;
}
-MapBlock* ServerMap::finishBlockMake(BlockMakeData *data,
- core::map<v3s16, MapBlock*> &changed_blocks)
+void ServerMap::finishBlockMake(BlockMakeData *data,
+ std::map<v3s16, MapBlock*> &changed_blocks)
{
v3s16 blockpos_min = data->blockpos_min;
v3s16 blockpos_max = data->blockpos_max;
v3s16 extra_borders(1,1,1);
- if(data->no_op)
- {
- //infostream<<"finishBlockMake(): no-op"<<std::endl;
- return NULL;
- }
-
- bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
+ bool enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
/*infostream<<"Resulting vmanip:"<<std::endl;
data->vmanip.print(infostream);*/
{
// 70ms @cs=8
//TimeTaker timer("finishBlockMake() blitBackAll");
- data->vmanip->blitBackAll(&changed_blocks);
+ data->vmanip->blitBackAll(&changed_blocks, false);
}
- if(enable_mapgen_debug_info)
- infostream<<"finishBlockMake: changed_blocks.size()="
- <<changed_blocks.size()<<std::endl;
+ EMERGE_DBG_OUT("finishBlockMake: changed_blocks.size()=" << changed_blocks.size());
/*
Copy transforming liquid information
y<=blockpos_max.Y+extra_borders.Y; y++)
{
v3s16 p(x, y, z);
- getBlockNoCreateNoEx(p)->setLightingExpired(false);
+ MapBlock * block = getBlockNoCreateNoEx(p);
+ if (block != NULL)
+ block->setLightingExpired(false);
}
#if 0
/*
Go through changed blocks
*/
- for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator i = changed_blocks.begin();
+ i != changed_blocks.end(); ++i)
{
- MapBlock *block = i.getNode()->getValue();
- assert(block);
+ MapBlock *block = i->second;
+ if (!block)
+ continue;
/*
Update day/night difference cache of the MapBlocks
*/
{
v3s16 p(x, y, z);
MapBlock *block = getBlockNoCreateNoEx(p);
- assert(block);
+ if (!block)
+ continue;
block->setGenerated(true);
}
/*infostream<<"finishBlockMake() done for ("<<blockpos_requested.X
<<","<<blockpos_requested.Y<<","
<<blockpos_requested.Z<<")"<<std::endl;*/
+
+
#if 0
if(enable_mapgen_debug_info)
{
}
#endif
- MapBlock *block = getBlockNoCreateNoEx(blockpos_requested);
- assert(block);
-
- return block;
+ getBlockNoCreateNoEx(blockpos_requested);
}
ServerMapSector * ServerMap::createSector(v2s16 p2d)
sector = new ServerMapSector(this, p2d, m_gamedef);
// Sector position on map in nodes
- v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
+ //v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
/*
Insert to container
*/
- m_sectors.insert(p2d, sector);
+ m_sectors[p2d] = sector;
return sector;
}
*/
MapBlock * ServerMap::generateBlock(
v3s16 p,
- core::map<v3s16, MapBlock*> &modified_blocks
+ std::map<v3s16, MapBlock*> &modified_blocks
)
{
DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
return block;
}
- /*if(allow_generate)
+
+#if 0
+ if(allow_generate)
{
- core::map<v3s16, MapBlock*> modified_blocks;
+ std::map<v3s16, MapBlock*> modified_blocks;
MapBlock *block = generateBlock(p, modified_blocks);
if(block)
{
event.p = p;
// Copy modified_blocks to event
- for(core::map<v3s16, MapBlock*>::Iterator
- i = modified_blocks.getIterator();
- i.atEnd()==false; i++)
+ for(std::map<v3s16, MapBlock*>::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- event.modified_blocks.insert(i.getNode()->getKey(), false);
+ event.modified_blocks.insert(i->first);
}
// Queue event
return block;
}
- }*/
+ }
+#endif
return NULL;
}
+MapBlock *ServerMap::getBlockOrEmerge(v3s16 p3d)
+{
+ MapBlock *block = getBlockNoCreateNoEx(p3d);
+ if (block == NULL)
+ m_emerge->enqueueBlockEmerge(PEER_ID_INEXISTENT, p3d, false);
+
+ return block;
+}
+
+void ServerMap::prepareBlock(MapBlock *block) {
+}
+
s16 ServerMap::findGroundLevel(v2s16 p2d)
{
#if 0
//return (s16)level;
}
-void ServerMap::createDatabase() {
- int e;
- assert(m_database);
- e = sqlite3_exec(m_database,
- "CREATE TABLE IF NOT EXISTS `blocks` ("
- "`pos` INT NOT NULL PRIMARY KEY,"
- "`data` BLOB"
- ");"
- , NULL, NULL, NULL);
- if(e == SQLITE_ABORT)
- throw FileNotGoodException("Could not create database structure");
- else
- infostream<<"ServerMap: Database structure was created";
-}
-
-void ServerMap::verifyDatabase() {
- if(m_database)
- return;
-
- {
- std::string dbp = m_savedir + DIR_DELIM + "map.sqlite";
- bool needs_create = false;
- int d;
-
- /*
- Open the database connection
- */
-
- createDirs(m_savedir);
-
- if(!fs::PathExists(dbp))
- needs_create = true;
-
- d = sqlite3_open_v2(dbp.c_str(), &m_database, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, NULL);
- if(d != SQLITE_OK) {
- infostream<<"WARNING: Database failed to open: "<<sqlite3_errmsg(m_database)<<std::endl;
- throw FileNotGoodException("Cannot open database file");
- }
-
- if(needs_create)
- createDatabase();
-
- d = sqlite3_prepare(m_database, "SELECT `data` FROM `blocks` WHERE `pos`=? LIMIT 1", -1, &m_database_read, NULL);
- if(d != SQLITE_OK) {
- infostream<<"WARNING: Database read statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
- throw FileNotGoodException("Cannot prepare read statement");
- }
-
- d = sqlite3_prepare(m_database, "REPLACE INTO `blocks` VALUES(?, ?)", -1, &m_database_write, NULL);
- if(d != SQLITE_OK) {
- infostream<<"WARNING: Database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
- throw FileNotGoodException("Cannot prepare write statement");
- }
-
- d = sqlite3_prepare(m_database, "SELECT `pos` FROM `blocks`", -1, &m_database_list, NULL);
- if(d != SQLITE_OK) {
- infostream<<"WARNING: Database list statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
- throw FileNotGoodException("Cannot prepare read statement");
- }
-
- infostream<<"ServerMap: Database opened"<<std::endl;
- }
-}
-
bool ServerMap::loadFromFolders() {
- if(!m_database && !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
+ if(!dbase->Initialized() && !fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite")) // ?
return true;
return false;
}
-sqlite3_int64 ServerMap::getBlockAsInteger(const v3s16 pos) {
- return (sqlite3_int64)pos.Z*16777216 +
- (sqlite3_int64)pos.Y*4096 + (sqlite3_int64)pos.X;
-}
-
void ServerMap::createDirs(std::string path)
{
if(fs::CreateAllDirs(path) == false)
return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
default:
assert(false);
+ return "";
}
}
v2s16 ServerMap::getSectorPos(std::string dirname)
{
- unsigned int x, y;
+ unsigned int x = 0, y = 0;
int r;
- size_t spos = dirname.rfind(DIR_DELIM_C) + 1;
- assert(spos != std::string::npos);
- if(dirname.size() - spos == 8)
+ std::string component;
+ fs::RemoveLastPathComponent(dirname, &component, 1);
+ if(component.size() == 8)
{
// Old layout
- r = sscanf(dirname.substr(spos).c_str(), "%4x%4x", &x, &y);
+ r = sscanf(component.c_str(), "%4x%4x", &x, &y);
}
- else if(dirname.size() - spos == 3)
+ else if(component.size() == 3)
{
// New layout
- r = sscanf(dirname.substr(spos-4).c_str(), "%3x" DIR_DELIM "%3x", &x, &y);
+ fs::RemoveLastPathComponent(dirname, &component, 2);
+ r = sscanf(component.c_str(), "%3x" DIR_DELIM "%3x", &x, &y);
// Sign-extend the 12 bit values up to 16 bits...
if(x&0x800) x|=0xF000;
if(y&0x800) y|=0xF000;
// Don't do anything with sqlite unless something is really saved
bool save_started = false;
- core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
- for(; i.atEnd() == false; i++)
+ for(std::map<v2s16, MapSector*>::iterator i = m_sectors.begin();
+ i != m_sectors.end(); ++i)
{
- ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
+ ServerMapSector *sector = (ServerMapSector*)i->second;
assert(sector->getId() == MAPSECTOR_SERVER);
if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN)
saveSectorMeta(sector);
sector_meta_count++;
}
- core::list<MapBlock*> blocks;
+ std::list<MapBlock*> blocks;
sector->getBlocks(blocks);
- core::list<MapBlock*>::Iterator j;
- for(j=blocks.begin(); j!=blocks.end(); j++)
+ for(std::list<MapBlock*>::iterator j = blocks.begin();
+ j != blocks.end(); ++j)
{
MapBlock *block = *j;
block_count_all++;
- if(block->getModified() >= save_level)
+ if(block->getModified() >= (u32)save_level)
{
// Lazy beginSave()
if(!save_started){
}
}
-static s32 unsignedToSigned(s32 i, s32 max_positive)
-{
- if(i < max_positive)
- return i;
- else
- return i - 2*max_positive;
-}
-
-// modulo of a negative number does not work consistently in C
-static sqlite3_int64 pythonmodulo(sqlite3_int64 i, sqlite3_int64 mod)
-{
- if(i >= 0)
- return i % mod;
- return mod - ((-i) % mod);
-}
-
-v3s16 ServerMap::getIntegerAsBlock(sqlite3_int64 i)
-{
- s32 x = unsignedToSigned(pythonmodulo(i, 4096), 2048);
- i = (i - x) / 4096;
- s32 y = unsignedToSigned(pythonmodulo(i, 4096), 2048);
- i = (i - y) / 4096;
- s32 z = unsignedToSigned(pythonmodulo(i, 4096), 2048);
- return v3s16(x,y,z);
-}
-
-void ServerMap::listAllLoadableBlocks(core::list<v3s16> &dst)
+void ServerMap::listAllLoadableBlocks(std::list<v3s16> &dst)
{
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)
+{
+ for(std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
+ si != m_sectors.end(); ++si)
{
- verifyDatabase();
+ MapSector *sector = si->second;
- while(sqlite3_step(m_database_list) == SQLITE_ROW)
+ std::list<MapBlock*> blocks;
+ sector->getBlocks(blocks);
+
+ for(std::list<MapBlock*>::iterator i = blocks.begin();
+ i != blocks.end(); ++i)
{
- sqlite3_int64 block_i = sqlite3_column_int64(m_database_list, 0);
- v3s16 p = getIntegerAsBlock(block_i);
- //dstream<<"block_i="<<block_i<<" p="<<PP(p)<<std::endl;
+ MapBlock *block = (*i);
+ v3s16 p = block->getPos();
dst.push_back(p);
}
}
createDirs(m_savedir);
std::string fullpath = m_savedir + DIR_DELIM + "map_meta.txt";
- std::ofstream os(fullpath.c_str(), std::ios_base::binary);
- if(os.good() == false)
- {
- infostream<<"ERROR: ServerMap::saveMapMeta(): "
- <<"could not open"<<fullpath<<std::endl;
- throw FileNotGoodException("Cannot open chunk metadata");
- }
+ std::ostringstream ss(std::ios_base::binary);
Settings params;
- m_emerge->setParamsToSettings(¶ms);
- params.writeLines(os);
+ m_emerge->saveParamsToSettings(¶ms);
+ params.writeLines(ss);
- os<<"[end_of_params]\n";
+ ss<<"[end_of_params]\n";
+
+ if(!fs::safeWriteToFile(fullpath, ss.str()))
+ {
+ infostream<<"ERROR: ServerMap::saveMapMeta(): "
+ <<"could not write "<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot save chunk metadata");
+ }
m_map_metadata_changed = false;
}
params.parseConfigLine(line);
}
- MapgenParams *mgparams = m_emerge->getParamsFromSettings(¶ms);
- if (mgparams) {
- if (m_mgparams)
- delete m_mgparams;
- m_mgparams = mgparams;
- m_seed = mgparams->seed;
- } else {
- if (params.exists("seed")) {
- m_seed = params.getU64("seed");
- m_mgparams->seed = m_seed;
- }
- }
+ m_emerge->loadParamsFromSettings(¶ms);
- verbosestream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl;
+ verbosestream<<"ServerMap::loadMapMeta(): seed="
+ << m_emerge->params.seed<<std::endl;
}
void ServerMap::saveSectorMeta(ServerMapSector *sector)
{
DSTACK(__FUNCTION_NAME);
// Format used for writing
- u8 version = SER_FMT_VER_HIGHEST;
+ u8 version = SER_FMT_VER_HIGHEST_WRITE;
// Get destination
v2s16 pos = sector->getPos();
std::string dir = getSectorDir(pos);
createDirs(dir);
std::string fullpath = dir + DIR_DELIM + "meta";
- std::ofstream o(fullpath.c_str(), std::ios_base::binary);
- if(o.good() == false)
- throw FileNotGoodException("Cannot open sector metafile");
+ std::ostringstream ss(std::ios_base::binary);
+
+ sector->serialize(ss, version);
- sector->serialize(o, version);
+ if(!fs::safeWriteToFile(fullpath, ss.str()))
+ throw FileNotGoodException("Cannot write sector metafile");
sector->differs_from_disk = false;
}
<<" Continuing with a sector with no metadata."
<<std::endl;*/
sector = new ServerMapSector(this, p2d, m_gamedef);
- m_sectors.insert(p2d, sector);
+ m_sectors[p2d] = sector;
}
else
{
}
#endif
-void ServerMap::beginSave() {
- verifyDatabase();
- if(sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL) != SQLITE_OK)
- infostream<<"WARNING: beginSave() failed, saving might be slow.";
+void ServerMap::beginSave()
+{
+ dbase->beginSave();
}
-void ServerMap::endSave() {
- verifyDatabase();
- if(sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL) != SQLITE_OK)
- infostream<<"WARNING: endSave() failed, map might not have saved.";
+void ServerMap::endSave()
+{
+ dbase->endSave();
}
-void ServerMap::saveBlock(MapBlock *block)
+bool ServerMap::saveBlock(MapBlock *block)
{
- DSTACK(__FUNCTION_NAME);
- /*
- Dummy blocks are not written
- */
- if(block->isDummy())
- {
- /*v3s16 p = block->getPos();
- infostream<<"ServerMap::saveBlock(): WARNING: Not writing dummy block "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
- return;
- }
+ return saveBlock(block, dbase);
+}
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST;
- // Get destination
+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;
+ }
-#if 0
- v2s16 p2d(p3d.X, p3d.Z);
- std::string sectordir = getSectorDir(p2d);
-
- createDirs(sectordir);
+ // Format used for writing
+ u8 version = SER_FMT_VER_HIGHEST_WRITE;
- std::string fullpath = sectordir+DIR_DELIM+getBlockFilename(p3d);
- std::ofstream o(fullpath.c_str(), std::ios_base::binary);
- if(o.good() == false)
- throw FileNotGoodException("Cannot open block data");
-#endif
/*
[0] u8 serialization version
[1] data
*/
-
- verifyDatabase();
-
std::ostringstream o(std::ios_base::binary);
-
- o.write((char*)&version, 1);
-
- // Write basic data
+ o.write((char*) &version, 1);
block->serialize(o, version, true);
- // Write block to database
-
- std::string tmp = o.str();
- const char *bytes = tmp.c_str();
-
- bool success = true;
- if(sqlite3_bind_int64(m_database_write, 1, getBlockAsInteger(p3d)) != SQLITE_OK) {
- infostream<<"WARNING: Block position failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
- success = false;
- }
- if(sqlite3_bind_blob(m_database_write, 2, (void *)bytes, o.tellp(), NULL) != SQLITE_OK) { // TODO this mught not be the right length
- infostream<<"WARNING: Block data failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
- success = false;
- }
- int written = sqlite3_step(m_database_write);
- if(written != SQLITE_DONE) {
- errorstream<<"WARNING: Block failed to save ("<<p3d.X<<", "<<p3d.Y<<", "<<p3d.Z<<") "
- <<sqlite3_errmsg(m_database)<<std::endl;
- success = false;
- }
- // Make ready for later reuse
- sqlite3_reset(m_database_write);
-
- // We just wrote it to the disk so clear modified flag
- if (success)
+ 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, MapSector *sector, bool save_after_load)
+void ServerMap::loadBlock(std::string sectordir, std::string blockfile,
+ MapSector *sector, bool save_after_load)
{
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)
Save blocks loaded in old format in new format
*/
- if(version < SER_FMT_VER_HIGHEST || save_after_load)
+ if(version < SER_FMT_VER_HIGHEST_WRITE || save_after_load)
{
saveBlock(block);
<<" (SerializationError). "
<<"what()="<<e.what()
<<std::endl;
- //" Ignoring. A new one will be generated.
+ // Ignoring. A new one will be generated.
assert(0);
// TODO: Backup file; name is in fullpath.
Save blocks loaded in old format in new format
*/
- //if(version < SER_FMT_VER_HIGHEST || save_after_load)
+ //if(version < SER_FMT_VER_HIGHEST_READ || save_after_load)
// Only save if asked to; no need to update version
if(save_after_load)
saveBlock(block);
v2s16 p2d(blockpos.X, blockpos.Z);
- if(!loadFromFolders()) {
- verifyDatabase();
-
- if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
- infostream<<"WARNING: Could not bind block position for load: "
- <<sqlite3_errmsg(m_database)<<std::endl;
- if(sqlite3_step(m_database_read) == SQLITE_ROW) {
- /*
- Make sure sector is loaded
- */
- MapSector *sector = createSector(p2d);
-
- /*
- Load block
- */
- const char * data = (const char *)sqlite3_column_blob(m_database_read, 0);
- size_t len = sqlite3_column_bytes(m_database_read, 0);
-
- std::string datastr(data, len);
+ std::string ret;
- loadBlock(&datastr, blockpos, sector, false);
-
- sqlite3_step(m_database_read);
- // We should never get more than 1 row, so ok to reset
- sqlite3_reset(m_database_read);
-
- return getBlockNoCreateNoEx(blockpos);
- }
- sqlite3_reset(m_database_read);
-
- // Not found in database, try the files
+ ret = dbase->loadBlock(blockpos);
+ 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.
// 1 - original sectors/xxxxzzzz/
out<<"ServerMap: ";
}
-/*
- MapVoxelManipulator
-*/
-
-MapVoxelManipulator::MapVoxelManipulator(Map *map)
-{
- m_map = map;
-}
-
-MapVoxelManipulator::~MapVoxelManipulator()
-{
- /*infostream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
- <<std::endl;*/
-}
-
-void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
-{
- TimeTaker timer1("emerge", &emerge_time);
-
- // Units of these are MapBlocks
- v3s16 p_min = getNodeBlockPos(a.MinEdge);
- v3s16 p_max = getNodeBlockPos(a.MaxEdge);
-
- VoxelArea block_area_nodes
- (p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-
- addArea(block_area_nodes);
-
- for(s32 z=p_min.Z; z<=p_max.Z; z++)
- for(s32 y=p_min.Y; y<=p_max.Y; y++)
- for(s32 x=p_min.X; x<=p_max.X; x++)
- {
- v3s16 p(x,y,z);
- core::map<v3s16, bool>::Node *n;
- n = m_loaded_blocks.find(p);
- if(n != NULL)
- continue;
-
- bool block_data_inexistent = false;
- try
- {
- TimeTaker timer1("emerge load", &emerge_load_time);
-
- /*infostream<<"Loading block (caller_id="<<caller_id<<")"
- <<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<" wanted area: ";
- a.print(infostream);
- infostream<<std::endl;*/
-
- MapBlock *block = m_map->getBlockNoCreate(p);
- if(block->isDummy())
- block_data_inexistent = true;
- else
- block->copyTo(*this);
- }
- catch(InvalidPositionException &e)
- {
- block_data_inexistent = true;
- }
-
- if(block_data_inexistent)
- {
- VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
- // Fill with VOXELFLAG_INEXISTENT
- for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
- for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
- {
- s32 i = m_area.index(a.MinEdge.X,y,z);
- memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
- }
- }
-
- m_loaded_blocks.insert(p, !block_data_inexistent);
- }
-
- //infostream<<"emerge done"<<std::endl;
-}
-
-/*
- SUGG: Add an option to only update eg. water and air nodes.
- This will make it interfere less with important stuff if
- run on background.
-*/
-void MapVoxelManipulator::blitBack
- (core::map<v3s16, MapBlock*> & modified_blocks)
-{
- if(m_area.getExtent() == v3s16(0,0,0))
- return;
-
- //TimeTaker timer1("blitBack");
-
- /*infostream<<"blitBack(): m_loaded_blocks.size()="
- <<m_loaded_blocks.size()<<std::endl;*/
-
- /*
- Initialize block cache
- */
- v3s16 blockpos_last;
- MapBlock *block = NULL;
- bool block_checked_in_modified = false;
-
- for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
- for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
- for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
- {
- v3s16 p(x,y,z);
-
- u8 f = m_flags[m_area.index(p)];
- if(f & (VOXELFLAG_NOT_LOADED|VOXELFLAG_INEXISTENT))
- continue;
-
- MapNode &n = m_data[m_area.index(p)];
-
- v3s16 blockpos = getNodeBlockPos(p);
-
- try
- {
- // Get block
- if(block == NULL || blockpos != blockpos_last){
- block = m_map->getBlockNoCreate(blockpos);
- blockpos_last = blockpos;
- block_checked_in_modified = false;
- }
-
- // Calculate relative position in block
- v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
-
- // Don't continue if nothing has changed here
- if(block->getNode(relpos) == n)
- continue;
-
- //m_map->setNode(m_area.MinEdge + p, n);
- block->setNode(relpos, n);
-
- /*
- Make sure block is in modified_blocks
- */
- if(block_checked_in_modified == false)
- {
- modified_blocks[blockpos] = block;
- block_checked_in_modified = true;
- }
- }
- catch(InvalidPositionException &e)
- {
- }
- }
-}
-
ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
- MapVoxelManipulator(map),
- m_create_area(false)
+ VoxelManipulator(),
+ m_create_area(false),
+ m_map(map)
{
}
{
}
-void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
-{
- // Just create the area so that it can be pointed to
- VoxelManipulator::emerge(a, caller_id);
-}
-
-void ManualMapVoxelManipulator::initialEmerge(
- v3s16 blockpos_min, v3s16 blockpos_max)
+void ManualMapVoxelManipulator::initialEmerge(v3s16 blockpos_min,
+ v3s16 blockpos_max, bool load_if_inexistent)
{
TimeTaker timer1("initialEmerge", &emerge_time);
for(s32 y=p_min.Y; y<=p_max.Y; y++)
for(s32 x=p_min.X; x<=p_max.X; x++)
{
+ u8 flags = 0;
+ MapBlock *block;
v3s16 p(x,y,z);
- core::map<v3s16, bool>::Node *n;
+ std::map<v3s16, u8>::iterator n;
n = m_loaded_blocks.find(p);
- if(n != NULL)
+ if(n != m_loaded_blocks.end())
continue;
bool block_data_inexistent = false;
{
TimeTaker timer1("emerge load", &emerge_load_time);
- MapBlock *block = m_map->getBlockNoCreate(p);
+ block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
else
if(block_data_inexistent)
{
- /*
- Mark area inexistent
- */
- VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
- // Fill with VOXELFLAG_INEXISTENT
- for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
- for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
- {
- s32 i = m_area.index(a.MinEdge.X,y,z);
- memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
+
+ if (load_if_inexistent) {
+ ServerMap *svrmap = (ServerMap *)m_map;
+ block = svrmap->emergeBlock(p, false);
+ if (block == NULL)
+ block = svrmap->createBlock(p);
+ else
+ block->copyTo(*this);
+ } else {
+ flags |= VMANIP_BLOCK_DATA_INEXIST;
+
+ /*
+ Mark area inexistent
+ */
+ VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
+ // Fill with VOXELFLAG_NO_DATA
+ for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
+ for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
+ {
+ s32 i = m_area.index(a.MinEdge.X,y,z);
+ memset(&m_flags[i], VOXELFLAG_NO_DATA, MAP_BLOCKSIZE);
+ }
}
}
+ /*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
+ {
+ // Mark that block was loaded as blank
+ flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
+ }*/
- m_loaded_blocks.insert(p, !block_data_inexistent);
+ m_loaded_blocks[p] = flags;
}
}
void ManualMapVoxelManipulator::blitBackAll(
- core::map<v3s16, MapBlock*> * modified_blocks)
+ std::map<v3s16, MapBlock*> *modified_blocks,
+ bool overwrite_generated)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
/*
Copy data of all blocks
*/
- for(core::map<v3s16, bool>::Iterator
- i = m_loaded_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, u8>::iterator
+ i = m_loaded_blocks.begin();
+ i != m_loaded_blocks.end(); ++i)
{
- v3s16 p = i.getNode()->getKey();
- bool existed = i.getNode()->getValue();
- if(existed == false)
- {
- // The Great Bug was found using this
- /*infostream<<"ManualMapVoxelManipulator::blitBackAll: "
- <<"Inexistent ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<std::endl;*/
- continue;
- }
+ v3s16 p = i->first;
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
- if(block == NULL)
- {
- infostream<<"WARNING: "<<__FUNCTION_NAME
- <<": got NULL block "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<std::endl;
+ bool existed = !(i->second & VMANIP_BLOCK_DATA_INEXIST);
+ if ((existed == false) || (block == NULL) ||
+ (overwrite_generated == false && block->isGenerated() == true))
continue;
- }
block->copyFrom(*this);
if(modified_blocks)
- modified_blocks->insert(p, block);
+ (*modified_blocks)[p] = block;
}
}