/*
-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 General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "mapblock.h"
#include "main.h"
#include "filesys.h"
-#include "utility.h"
#include "voxel.h"
#include "porting.h"
-#include "mapgen.h"
+#include "serialization.h"
#include "nodemetadata.h"
#include "settings.h"
#include "log.h"
#include "profiler.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
#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
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);
}
}
MapSector * sector = m_sector_cache;
return sector;
}
-
- core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
-
- if(n == NULL)
+
+ std::map<v2s16, MapSector*>::iterator n = m_sectors.find(p);
+
+ if(n == m_sectors.end())
return NULL;
-
- MapSector *sector = n->getValue();
-
+
+ MapSector *sector = n->second;
+
// Cache the last result
m_sector_cache_p = p;
m_sector_cache = sector;
MapSector *sector = getSectorNoGenerateNoEx(p);
if(sector == NULL)
throw InvalidPositionException();
-
+
return sector;
}
}
MapBlock * Map::getBlockNoCreate(v3s16 p3d)
-{
+{
MapBlock *block = getBlockNoCreateNoEx(p3d);
if(block == NULL)
throw InvalidPositionException();
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();
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
};
-
+
if(from_nodes.size() == 0)
return;
-
+
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
MapBlock *block = NULL;
// 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
try{
if(block == NULL || blockpos != blockpos_last){
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)
#if 0
{
//MapVoxelManipulator vmanip(this);
-
+
// Make a manual voxel manipulator and load all the blocks
// that touch the requested blocks
ManualMapVoxelManipulator vmanip(this);
//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 *nodemgr = m_gamedef->ndef();
+ INodeDefManager *ndef = m_gamedef->ndef();
/*PrintInfo(m_dout);
m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
*/
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
+ */
+ RollbackNode rollback_oldnode(this, p, m_gamedef);
/*
If there is a node at top and it doesn't have sunlight,
try{
MapNode topnode = getNode(toppos);
- if(topnode.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN)
+ if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
node_under_sunlight = false;
}
catch(InvalidPositionException &e)
{
enum LightBank bank = banks[i];
- u8 lightwas = getNode(p).getLight(bank, nodemgr);
+ u8 lightwas = getNode(p).getLight(bank, ndef);
// Add the block of the added node to modified_blocks
v3s16 blockpos = getNodeBlockPos(p);
MapBlock * block = getBlockNoCreate(blockpos);
assert(block != NULL);
- modified_blocks.insert(blockpos, block);
+ modified_blocks[blockpos] = block;
assert(isValidPosition(p));
// light again into this.
unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks);
- n.setLight(bank, 0, nodemgr);
+ n.setLight(bank, 0, ndef);
}
/*
If node lets sunlight through and is under sunlight, it has
sunlight too.
*/
- if(node_under_sunlight && nodemgr->get(n).sunlight_propagates)
+ if(node_under_sunlight && ndef->get(n).sunlight_propagates)
{
- n.setLight(LIGHTBANK_DAY, LIGHT_SUN, nodemgr);
+ n.setLight(LIGHTBANK_DAY, LIGHT_SUN, ndef);
}
/*
- Set the node on the map
+ Remove node metadata
*/
-
- setNode(p, n);
+ if (remove_metadata) {
+ removeNodeMetadata(p);
+ }
/*
- Add intial metadata
+ Set the node on the map
*/
-
- std::string metadata_name = nodemgr->get(n).metadata_name;
- if(metadata_name != ""){
- NodeMetadata *meta = NodeMetadata::create(metadata_name, m_gamedef);
- if(!meta){
- errorstream<<"Failed to create node metadata \""
- <<metadata_name<<"\""<<std::endl;
- } else {
- setNodeMetadata(p, meta);
- }
- }
+
+ setNode(p, n);
/*
If node is under sunlight and doesn't let sunlight through,
TODO: This could be optimized by mass-unlighting instead
of looping
*/
- if(node_under_sunlight && !nodemgr->get(n).sunlight_propagates)
+ if(node_under_sunlight && !ndef->get(n).sunlight_propagates)
{
s16 y = p.Y - 1;
for(;; y--){
break;
}
- if(n2.getLight(LIGHTBANK_DAY, nodemgr) == LIGHT_SUN)
+ if(n2.getLight(LIGHTBANK_DAY, ndef) == LIGHT_SUN)
{
unLightNeighbors(LIGHTBANK_DAY,
- n2pos, n2.getLight(LIGHTBANK_DAY, nodemgr),
+ n2pos, n2.getLight(LIGHTBANK_DAY, ndef),
light_sources, modified_blocks);
- n2.setLight(LIGHTBANK_DAY, 0, nodemgr);
+ n2.setLight(LIGHTBANK_DAY, 0, ndef);
setNode(n2pos, n2);
}
else
/*
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();
+ }
+
+ /*
+ Report for rollback
+ */
+ if(m_gamedef->rollback())
+ {
+ RollbackNode rollback_newnode(this, p, m_gamedef);
+ RollbackAction action;
+ action.setSetNode(p, rollback_oldnode, rollback_newnode);
+ m_gamedef->rollback()->reportAction(action);
}
/*
Add neighboring liquid nodes and the node itself if it is
liquid (=water node was added) to transform queue.
+ note: todo: for liquid_finite enough to add only self node
*/
v3s16 dirs[7] = {
v3s16(0,0,0), // self
v3s16 p2 = p + dirs[i];
MapNode n2 = getNode(p2);
- if(nodemgr->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+ if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
{
m_transforming_liquid.push_back(p2);
}
/*
*/
void Map::removeNodeAndUpdate(v3s16 p,
- core::map<v3s16, MapBlock*> &modified_blocks)
+ std::map<v3s16, MapBlock*> &modified_blocks)
{
- INodeDefManager *nodemgr = m_gamedef->ndef();
+ INodeDefManager *ndef = m_gamedef->ndef();
/*PrintInfo(m_dout);
m_dout<<DTIME<<"Map::removeNodeAndUpdate(): p=("
// Node will be replaced with this
content_t replace_material = CONTENT_AIR;
+ /*
+ Collect old node for rollback
+ */
+ RollbackNode rollback_oldnode(this, p, m_gamedef);
+
/*
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);
- if(topnode.getLight(LIGHTBANK_DAY, nodemgr) != LIGHT_SUN)
+ if(topnode.getLight(LIGHTBANK_DAY, ndef) != LIGHT_SUN)
node_under_sunlight = false;
}
catch(InvalidPositionException &e)
{
}
- core::map<v3s16, bool> light_sources;
+ std::set<v3s16> light_sources;
enum LightBank banks[] =
{
Unlight neighbors (in case the node is a light source)
*/
unLightNeighbors(bank, p,
- getNode(p).getLight(bank, nodemgr),
+ getNode(p).getLight(bank, ndef),
light_sources, modified_blocks);
}
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
// TODO: Is this needed? Lighting is cleared up there already.
try{
MapNode n = getNode(p);
- n.setLight(LIGHTBANK_DAY, 0, nodemgr);
+ n.setLight(LIGHTBANK_DAY, 0, ndef);
setNode(p, n);
}
catch(InvalidPositionException &e)
// 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();
+ }
+
+ /*
+ Report for rollback
+ */
+ if(m_gamedef->rollback())
+ {
+ RollbackNode rollback_newnode(this, p, m_gamedef);
+ RollbackAction action;
+ action.setSetNode(p, rollback_oldnode, rollback_newnode);
+ m_gamedef->rollback()->reportAction(action);
}
/*
Add neighboring liquid nodes and this node to transform queue.
(it's vital for the node itself to get updated last.)
+ note: todo: for liquid_finite enough to add only self node
*/
v3s16 dirs[7] = {
v3s16(0,0,1), // back
v3s16 p2 = p + dirs[i];
MapNode n2 = getNode(p2);
- if(nodemgr->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
+ if(ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR)
{
m_transforming_liquid.push_back(p2);
}
}
}
-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);
-
+
block->incrementUsageTimer(dtime);
-
- if(block->getUsageTimer() > unload_timeout)
+
+ if(block->refGet() == 0 && block->getUsageTimer() > unload_timeout)
{
v3s16 p = block->getPos();
if(all_blocks_deleted)
{
- sector_deletion_queue.push_back(si.getNode()->getKey());
+ sector_deletion_queue.push_back(si->first);
}
}
endSave();
-
+
// Finally delete the empty sectors
deleteSectors(sector_deletion_queue);
-
+
if(deleted_blocks_count != 0)
{
PrintInfo(infostream); // ServerMap/ClientMap:
}
}
-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;
}
}
i != blocks.end(); i++)
{
MapBlock *block = (*i);
-
+
if(block->getUsageTimer() > timeout)
{
// Save if modified
MapNode n;
NeighborType t;
v3s16 p;
+ bool l; //can liquid
+ bool i; //infinity
+};
+
+void Map::transforming_liquid_add(v3s16 p) {
+ m_transforming_liquid.push_back(p);
+}
+
+s32 Map::transforming_liquid_size() {
+ return m_transforming_liquid.size();
+}
+
+const v3s16 g_7dirs[7] =
+{
+ // +right, +top, +back
+ v3s16( 0,-1, 0), // bottom
+ v3s16( 0, 0, 0), // self
+ v3s16( 0, 0, 1), // back
+ v3s16( 0, 0,-1), // front
+ v3s16( 1, 0, 0), // right
+ v3s16(-1, 0, 0), // left
+ v3s16( 0, 1, 0) // top
};
-void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
+#define D_BOTTOM 0
+#define D_TOP 6
+#define D_SELF 1
+
+void Map::transformLiquidsFinite(std::map<v3s16, MapBlock*> & modified_blocks)
+{
+ INodeDefManager *nodemgr = m_gamedef->ndef();
+
+ DSTACK(__FUNCTION_NAME);
+ //TimeTaker timer("transformLiquids()");
+
+ u32 loopcount = 0;
+ u32 initial_size = m_transforming_liquid.size();
+
+ u8 relax = g_settings->getS16("liquid_relax");
+ bool fast_flood = g_settings->getS16("liquid_fast_flood");
+ int water_level = g_settings->getS16("water_level");
+
+ // list of nodes that due to viscosity have not reached their max level height
+ UniqueQueue<v3s16> must_reflow, must_reflow_second;
+
+ // 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");
+
+ //if (m_transforming_liquid.size() > 0) errorstream << "Liquid queue size="<<m_transforming_liquid.size()<<std::endl;
+
+ 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 >= loop_max)
+ break;
+ loopcount++;
+ /*
+ Get a queued transforming liquid node
+ */
+ v3s16 p0 = m_transforming_liquid.pop_front();
+ u16 total_level = 0;
+ // surrounding flowing liquid nodes
+ NodeNeighbor neighbors[7];
+ // current level of every block
+ s8 liquid_levels[7] = {-1, -1, -1, -1, -1, -1, -1};
+ // target levels
+ s8 liquid_levels_want[7] = {-1, -1, -1, -1, -1, -1, -1};
+ s8 can_liquid_same_level = 0;
+ content_t liquid_kind = CONTENT_IGNORE;
+ content_t liquid_kind_flowing = CONTENT_IGNORE;
+ /*
+ Collect information about the environment
+ */
+ const v3s16 *dirs = g_7dirs;
+ for (u16 i = 0; i < 7; i++) {
+ NeighborType nt = NEIGHBOR_SAME_LEVEL;
+ switch (i) {
+ case D_TOP:
+ nt = NEIGHBOR_UPPER;
+ break;
+ case D_BOTTOM:
+ nt = NEIGHBOR_LOWER;
+ break;
+ }
+ v3s16 npos = p0 + dirs[i];
+
+ neighbors[i].n = getNodeNoEx(npos);
+ neighbors[i].t = nt;
+ neighbors[i].p = npos;
+ neighbors[i].l = 0;
+ neighbors[i].i = 0;
+ NodeNeighbor & nb = neighbors[i];
+
+ switch (nodemgr->get(nb.n.getContent()).liquid_type) {
+ case LIQUID_NONE:
+ if (nb.n.getContent() == CONTENT_AIR) {
+ liquid_levels[i] = 0;
+ nb.l = 1;
+ }
+ break;
+ case LIQUID_SOURCE:
+ // if this node is not (yet) of a liquid type,
+ // choose the first liquid type we encounter
+ if (liquid_kind_flowing == CONTENT_IGNORE)
+ liquid_kind_flowing = nodemgr->getId(
+ nodemgr->get(nb.n).liquid_alternative_flowing);
+ if (liquid_kind == CONTENT_IGNORE)
+ liquid_kind = nb.n.getContent();
+ if (nb.n.getContent() == liquid_kind) {
+ liquid_levels[i] = nb.n.getLevel(nodemgr); //LIQUID_LEVEL_SOURCE;
+ nb.l = 1;
+ nb.i = (nb.n.param2 & LIQUID_INFINITY_MASK);
+ }
+ break;
+ case LIQUID_FLOWING:
+ // if this node is not (yet) of a liquid type,
+ // choose the first liquid type we encounter
+ if (liquid_kind_flowing == CONTENT_IGNORE)
+ liquid_kind_flowing = nb.n.getContent();
+ if (liquid_kind == CONTENT_IGNORE)
+ liquid_kind = nodemgr->getId(
+ nodemgr->get(nb.n).liquid_alternative_source);
+ if (nb.n.getContent() == liquid_kind_flowing) {
+ liquid_levels[i] = nb.n.getLevel(nodemgr); //(nb.n.param2 & LIQUID_LEVEL_MASK);
+ nb.l = 1;
+ }
+ break;
+ }
+
+ if (nb.l && nb.t == NEIGHBOR_SAME_LEVEL)
+ ++can_liquid_same_level;
+ if (liquid_levels[i] > 0)
+ total_level += liquid_levels[i];
+
+ /*
+ infostream << "get node i=" <<(int)i<<" " << PP(npos) << " c="
+ << nb.n.getContent() <<" p0="<< (int)nb.n.param0 <<" p1="
+ << (int)nb.n.param1 <<" p2="<< (int)nb.n.param2 << " lt="
+ << nodemgr->get(nb.n.getContent()).liquid_type
+ //<< " lk=" << liquid_kind << " lkf=" << liquid_kind_flowing
+ << " l="<< nb.l << " inf="<< nb.i << " nlevel=" << (int)liquid_levels[i]
+ << " tlevel=" << (int)total_level << " cansame="
+ << (int)can_liquid_same_level << std::endl;
+ */
+ }
+
+ if (liquid_kind == CONTENT_IGNORE ||
+ !neighbors[D_SELF].l ||
+ total_level <= 0)
+ continue;
+
+ // fill bottom block
+ if (neighbors[D_BOTTOM].l) {
+ liquid_levels_want[D_BOTTOM] = total_level > LIQUID_LEVEL_SOURCE ?
+ LIQUID_LEVEL_SOURCE : total_level;
+ total_level -= liquid_levels_want[D_BOTTOM];
+ }
+
+ //relax up
+ if (relax && ((p0.Y == water_level) || (fast_flood && p0.Y <= water_level)) && liquid_levels[D_TOP] == 0 &&
+ liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE &&
+ total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level-
+ (can_liquid_same_level - relax) &&
+ can_liquid_same_level >= relax + 1) {
+ total_level = LIQUID_LEVEL_SOURCE * can_liquid_same_level;
+ }
+
+ // prevent lakes in air above unloaded blocks
+ if (liquid_levels[D_TOP] == 0 && (p0.Y > water_level) && neighbors[D_BOTTOM].n.getContent() == CONTENT_IGNORE && !(loopcount % 3)) {
+ --total_level;
+ }
+
+ // calculate self level 5 blocks
+ u8 want_level =
+ total_level >= LIQUID_LEVEL_SOURCE * can_liquid_same_level
+ ? LIQUID_LEVEL_SOURCE
+ : total_level / can_liquid_same_level;
+ total_level -= want_level * can_liquid_same_level;
+
+ //relax down
+ if (relax && p0.Y == water_level + 1 && liquid_levels[D_TOP] == 0 &&
+ liquid_levels[D_BOTTOM] == LIQUID_LEVEL_SOURCE && want_level == 0 &&
+ total_level <= (can_liquid_same_level - relax) &&
+ can_liquid_same_level >= relax + 1) {
+ total_level = 0;
+ }
+
+ for (u16 ii = D_SELF; ii < D_TOP; ++ii) { // fill only same level
+ if (!neighbors[ii].l)
+ continue;
+ liquid_levels_want[ii] = want_level;
+ if (liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE && total_level > 0) {
+ if (loopcount % 3 || liquid_levels[ii] <= 0){
+ if (liquid_levels[ii] > liquid_levels_want[ii]) {
+ ++liquid_levels_want[ii];
+ --total_level;
+ }
+ } else if (neighbors[ii].l > 0){
+ ++liquid_levels_want[ii];
+ --total_level;
+ }
+ }
+ }
+
+ for (u16 ii = 0; ii < 7; ++ii) {
+ if (total_level < 1) break;
+ if (liquid_levels_want[ii] >= 0 &&
+ liquid_levels_want[ii] < LIQUID_LEVEL_SOURCE) {
+ ++liquid_levels_want[ii];
+ --total_level;
+ }
+ }
+
+ // fill top block if can
+ if (neighbors[D_TOP].l) {
+ liquid_levels_want[D_TOP] = total_level > LIQUID_LEVEL_SOURCE ?
+ LIQUID_LEVEL_SOURCE : total_level;
+ total_level -= liquid_levels_want[D_TOP];
+ }
+
+ for (u16 ii = 0; ii < 7; ii++) // infinity and cave flood optimization
+ if ( neighbors[ii].i ||
+ (liquid_levels_want[ii] >= 0 &&
+ (fast_flood && p0.Y < water_level &&
+ (initial_size >= 1000
+ && ii != D_TOP
+ && want_level >= LIQUID_LEVEL_SOURCE/4
+ && can_liquid_same_level >= 5
+ && liquid_levels[D_TOP] >= LIQUID_LEVEL_SOURCE))))
+ liquid_levels_want[ii] = LIQUID_LEVEL_SOURCE;
+
+ /*
+ if (total_level > 0) //|| flowed != volume)
+ infostream <<" AFTER level=" << (int)total_level
+ //<< " flowed="<<flowed<< " volume=" << volume
+ << " wantsame="<<(int)want_level<< " top="
+ << (int)liquid_levels_want[D_TOP]<< " topwas="
+ << (int)liquid_levels[D_TOP]<< " bot="
+ << (int)liquid_levels_want[D_BOTTOM]<<std::endl;
+ */
+
+ //u8 changed = 0;
+ for (u16 i = 0; i < 7; i++) {
+ if (liquid_levels_want[i] < 0 || !neighbors[i].l)
+ continue;
+ MapNode & n0 = neighbors[i].n;
+ p0 = neighbors[i].p;
+ /*
+ decide on the type (and possibly level) of the current node
+ */
+ content_t new_node_content;
+ s8 new_node_level = -1;
+ u8 viscosity = nodemgr->get(liquid_kind).liquid_viscosity;
+ if (viscosity > 1 && liquid_levels_want[i] != liquid_levels[i]) {
+ // amount to gain, limited by viscosity
+ // must be at least 1 in absolute value
+ s8 level_inc = liquid_levels_want[i] - liquid_levels[i];
+ if (level_inc < -viscosity || level_inc > viscosity)
+ new_node_level = liquid_levels[i] + level_inc/viscosity;
+ else if (level_inc < 0)
+ new_node_level = liquid_levels[i] - 1;
+ else if (level_inc > 0)
+ new_node_level = liquid_levels[i] + 1;
+ } else {
+ new_node_level = liquid_levels_want[i];
+ }
+
+ if (new_node_level >= LIQUID_LEVEL_SOURCE)
+ new_node_content = liquid_kind;
+ else if (new_node_level > 0)
+ new_node_content = liquid_kind_flowing;
+ else
+ new_node_content = CONTENT_AIR;
+
+ // last level must flow down on stairs
+ if (liquid_levels_want[i] != liquid_levels[i] &&
+ liquid_levels[D_TOP] <= 0 && !neighbors[D_BOTTOM].l &&
+ new_node_level >= 1 && new_node_level <= 2) {
+ for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) { // only same level
+ if (neighbors[ii].l)
+ must_reflow_second.push_back(p0 + dirs[ii]);
+ }
+ }
+
+ /*
+ check if anything has changed.
+ if not, just continue with the next node.
+ */
+ /*
+ if (
+ new_node_content == n0.getContent()
+ && (nodemgr->get(n0.getContent()).liquid_type != LIQUID_FLOWING ||
+ (n0.getLevel(nodemgr) == (u8)new_node_level
+ //&& ((n0.param2 & LIQUID_FLOW_DOWN_MASK) ==
+ //LIQUID_FLOW_DOWN_MASK) == flowing_down
+ ))
+ &&
+ (nodemgr->get(n0.getContent()).liquid_type != LIQUID_SOURCE ||
+ (((n0.param2 & LIQUID_INFINITY_MASK) ==
+ LIQUID_INFINITY_MASK) == neighbors[i].i
+ ))
+ )*/
+ if (liquid_levels[i] == new_node_level)
+ {
+ continue;
+ }
+
+ //++changed;
+
+ /*
+ update the current node
+ */
+ /*
+ if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) {
+ // set level to last 3 bits, flowing down bit to 4th bit
+ n0.param2 = (new_node_level & LIQUID_LEVEL_MASK);
+ } else if (nodemgr->get(new_node_content).liquid_type == LIQUID_SOURCE) {
+ //n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
+ n0.param2 = (neighbors[i].i ? LIQUID_INFINITY_MASK : 0x00);
+ }
+ */
+ /*
+ infostream << "set node i=" <<(int)i<<" "<< PP(p0)<< " nc="
+ <<new_node_content<< " p2="<<(int)n0.param2<< " nl="
+ <<(int)new_node_level<<std::endl;
+ */
+
+ n0.setContent(liquid_kind_flowing);
+ n0.setLevel(nodemgr, new_node_level);
+ // Find out whether there is a suspect for this action
+ std::string suspect;
+ if(m_gamedef->rollback()){
+ suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
+ }
+
+ if(!suspect.empty()){
+ // Blame suspect
+ RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
+ // Get old node for rollback
+ RollbackNode rollback_oldnode(this, p0, m_gamedef);
+ // Set node
+ setNode(p0, n0);
+ // Report
+ RollbackNode rollback_newnode(this, p0, m_gamedef);
+ RollbackAction action;
+ action.setSetNode(p0, rollback_oldnode, rollback_newnode);
+ m_gamedef->rollback()->reportAction(action);
+ } else {
+ // Set node
+ setNode(p0, n0);
+ }
+
+ v3s16 blockpos = getNodeBlockPos(p0);
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block != NULL) {
+ modified_blocks[blockpos] = block;
+ // If node emits light, MapBlock requires lighting update
+ if(nodemgr->get(n0).light_source != 0)
+ lighting_modified_blocks[block->getPos()] = block;
+ }
+ must_reflow.push_back(neighbors[i].p);
+ }
+ /* //for better relax only same level
+ if (changed) for (u16 ii = D_SELF + 1; ii < D_TOP; ++ii) {
+ if (!neighbors[ii].l) continue;
+ must_reflow.push_back(p0 + dirs[ii]);
+ }*/
+ }
+ /*
+ if (loopcount)
+ infostream<<"Map::transformLiquids(): loopcount="<<loopcount
+ <<" reflow="<<must_reflow.size()
+ <<" queue="<< m_transforming_liquid.size()<<std::endl;
+ */
+ while (must_reflow.size() > 0)
+ m_transforming_liquid.push_back(must_reflow.pop_front());
+ while (must_reflow_second.size() > 0)
+ m_transforming_liquid.push_back(must_reflow_second.pop_front());
+ updateLighting(lighting_modified_blocks, modified_blocks);
+}
+
+void Map::transformLiquids(std::map<v3s16, MapBlock*> & modified_blocks)
{
+
+ if (g_settings->getBool("liquid_finite"))
+ return Map::transformLiquidsFinite(modified_blocks);
+
INodeDefManager *nodemgr = m_gamedef->ndef();
DSTACK(__FUNCTION_NAME);
// list of nodes that due to viscosity have not reached their max level height
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 * 3)
+ if(loopcount >= initial_size || loopcount >= loop_max)
break;
loopcount++;
Collect information about current node
*/
s8 liquid_level = -1;
- u8 liquid_kind = CONTENT_IGNORE;
+ content_t liquid_kind = CONTENT_IGNORE;
LiquidType liquid_type = nodemgr->get(n0).liquid_type;
switch (liquid_type) {
case LIQUID_SOURCE:
}
break;
case LIQUID_SOURCE:
- // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
+ // if this node is not (yet) of a liquid type, choose the first liquid type we encounter
if (liquid_kind == CONTENT_AIR)
liquid_kind = nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing);
if (nodemgr->getId(nodemgr->get(nb.n).liquid_alternative_flowing) != liquid_kind) {
content_t new_node_content;
s8 new_node_level = -1;
s8 max_node_level = -1;
- if (num_sources >= 2 || liquid_type == LIQUID_SOURCE) {
+ 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
// it's perfectly safe to use liquid_kind here to determine the new node content.
new_node_content = nodemgr->getId(nodemgr->get(liquid_kind).liquid_alternative_source);
- } else if (num_sources == 1 && sources[0].t != NEIGHBOR_LOWER) {
+ } else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
// 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
n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
}
n0.setContent(new_node_content);
- setNode(p0, n0);
+
+ // Find out whether there is a suspect for this action
+ std::string suspect;
+ if(m_gamedef->rollback()){
+ suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
+ }
+
+ if(!suspect.empty()){
+ // Blame suspect
+ RollbackScopeActor rollback_scope(m_gamedef->rollback(), suspect, true);
+ // Get old node for rollback
+ RollbackNode rollback_oldnode(this, p0, m_gamedef);
+ // Set node
+ setNode(p0, n0);
+ // Report
+ RollbackNode rollback_newnode(this, p0, m_gamedef);
+ RollbackAction action;
+ action.setSetNode(p0, rollback_oldnode, rollback_newnode);
+ m_gamedef->rollback()->reportAction(action);
+ } else {
+ // Set node
+ setNode(p0, n0);
+ }
+
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;
}
- NodeMetadata *meta = block->m_node_metadata->get(p_rel);
+ NodeMetadata *meta = block->m_node_metadata.get(p_rel);
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);
+ block->m_node_metadata.set(p_rel, meta);
+ return true;
}
void Map::removeNodeMetadata(v3s16 p)
<<std::endl;
return;
}
- block->m_node_metadata->remove(p_rel);
+ block->m_node_metadata.remove(p_rel);
}
-void Map::nodeMetadataStep(float dtime,
- core::map<v3s16, MapBlock*> &changed_blocks)
+NodeTimer Map::getNodeTimer(v3s16 p)
{
- /*
- NOTE:
- Currently there is no way to ensure that all the necessary
- blocks are loaded when this is run. (They might get unloaded)
- NOTE: ^- Actually, that might not be so. In a quick test it
- reloaded a block with a furnace when I walked back to it from
- a distance.
- */
- core::map<v2s16, MapSector*>::Iterator si;
- si = m_sectors.getIterator();
- for(; si.atEnd() == false; si++)
- {
- MapSector *sector = si.getNode()->getValue();
- core::list< MapBlock * > sectorblocks;
- sector->getBlocks(sectorblocks);
- core::list< MapBlock * >::Iterator i;
- for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
- {
- MapBlock *block = *i;
- bool changed = block->m_node_metadata->step(dtime);
- if(changed)
- changed_blocks[block->getPos()] = block;
- }
- }
-}
-
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(!block){
+ infostream<<"Map::getNodeTimer(): Need to emerge "
+ <<PP(blockpos)<<std::endl;
+ block = emergeBlock(blockpos, false);
+ }
+ if(!block){
+ infostream<<"WARNING: Map::getNodeTimer(): Block not found"
+ <<std::endl;
+ return NodeTimer();
+ }
+ NodeTimer t = block->m_node_timers.get(p_rel);
+ return t;
+}
+
+void Map::setNodeTimer(v3s16 p, NodeTimer t)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(!block){
+ infostream<<"Map::setNodeTimer(): Need to emerge "
+ <<PP(blockpos)<<std::endl;
+ block = emergeBlock(blockpos, false);
+ }
+ if(!block){
+ infostream<<"WARNING: Map::setNodeTimer(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_timers.set(p_rel, t);
+}
+
+void Map::removeNodeTimer(v3s16 p)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ infostream<<"WARNING: Map::removeNodeTimer(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_timers.remove(p_rel);
+}
+
+s16 Map::getHeat(v3s16 p)
+{
+ MapBlock *block = getBlockNoCreateNoEx(getNodeBlockPos(p));
+ if(block != NULL) {
+ return block->heat;
+ }
+ //errorstream << "No heat for " << p.X<<"," << p.Z << std::endl;
+ return 0;
+}
+
+s16 Map::getHumidity(v3s16 p)
+{
+ MapBlock *block = getBlockNoCreateNoEx(getNodeBlockPos(p));
+ if(block != NULL) {
+ return block->humidity;
+ }
+ //errorstream << "No humidity for " << p.X<<"," << p.Z << std::endl;
+ return 0;
+}
+
/*
ServerMap
*/
-
-ServerMap::ServerMap(std::string savedir, IGameDef *gamedef):
+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_map_metadata_changed(true)
{
verbosestream<<__FUNCTION_NAME<<std::endl;
- //m_chunksize = 8; // Takes a few seconds
+ 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));
- }
- else
- {
- m_seed = g_settings->getU64("fixed_map_seed");
+ m_seed = (((u64)(myrand() & 0xffff) << 0)
+ | ((u64)(myrand() & 0xffff) << 16)
+ | ((u64)(myrand() & 0xffff) << 32)
+ | ((u64)(myrand() & 0xffff) << 48));
+ m_mgparams->seed = m_seed;
}
/*
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
+ else
+ throw BaseException("Unknown map backend");
+ }
+
m_savedir = savedir;
m_map_saving_enabled = false;
// Load map metadata (seed, chunksize)
loadMapMeta();
}
+ catch(SettingNotFoundException &e){
+ infostream<<"ServerMap: Some metadata not found."
+ <<" Using default settings."<<std::endl;
+ }
catch(FileNotGoodException &e){
infostream<<"WARNING: Could not load map metadata"
//<<" Disabling chunk-based generator."
/*
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
/*
delete chunk;
}
#endif
+
+ delete m_mgparams;
}
-void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos)
+bool ServerMap::initBlockMake(BlockMakeData *data, v3s16 blockpos)
{
- 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;
-
- //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 enable_mapgen_debug_info = m_emerge->mapgen_debug_info;
+ EMERGE_DBG_OUT("initBlockMake(): " PP(blockpos) " - " PP(blockpos));
+
+ s16 chunksize = m_mgparams->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;
- }
-
- data->no_op = false;
+ return false;
+
data->seed = m_seed;
data->blockpos_min = blockpos_min;
data->blockpos_max = blockpos_max;
*/
{
//TimeTaker timer("initBlockMake() create area");
-
+
for(s16 x=blockpos_min.X-extra_borders.X;
x<=blockpos_max.X+extra_borders.X; x++)
for(s16 z=blockpos_min.Z-extra_borders.Z;
Refer to the map generator heuristics.
*/
- bool ug = mapgen::block_is_underground(data->seed, p);
+ bool ug = m_emerge->isBlockUnderground(p);
block->setIsUnderground(ug);
}
}
}
}
-
+
/*
Now we have a big empty area.
Make a ManualMapVoxelManipulator that contains this and the
neighboring blocks
*/
-
+
// The area that contains this block and it's neighbors
v3s16 bigarea_blocks_min = blockpos_min - extra_borders;
v3s16 bigarea_blocks_max = blockpos_max + extra_borders;
-
+
data->vmanip = new ManualMapVoxelManipulator(this);
//data->vmanip->setMap(this);
// 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(mapgen::BlockMakeData *data,
- core::map<v3s16, MapBlock*> &changed_blocks)
+MapBlock* 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);*/
data->vmanip->blitBackAll(&changed_blocks);
}
- 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
TimeTaker t("finishBlockMake lighting update");
core::map<v3s16, MapBlock*> lighting_update_blocks;
-
+
// Center blocks
for(s16 x=blockpos_min.X-extra_borders.X;
x<=blockpos_max.X+extra_borders.X; x++)
updateLighting(lighting_update_blocks, changed_blocks);
#endif
-
+
/*
Set lighting to non-expired state in all of them.
This is cheating, but it is not fast enough if all of them
/*
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();
+ MapBlock *block = i->second;
assert(block);
/*
Update day/night difference cache of the MapBlocks
assert(block);
block->setGenerated(true);
}
-
+
/*
Save changed parts of map
NOTE: Will be saved later.
/*infostream<<"finishBlockMake() done for ("<<blockpos_requested.X
<<","<<blockpos_requested.Y<<","
<<blockpos_requested.Z<<")"<<std::endl;*/
+
+ /*
+ Update weather data in blocks
+ */
+ ServerEnvironment *senv = &((Server *)m_gamedef)->getEnv();
+ for(s16 x=blockpos_min.X-extra_borders.X;
+ x<=blockpos_max.X+extra_borders.X; x++)
+ for(s16 z=blockpos_min.Z-extra_borders.Z;
+ z<=blockpos_max.Z+extra_borders.Z; z++)
+ for(s16 y=blockpos_min.Y-extra_borders.Y;
+ y<=blockpos_max.Y+extra_borders.Y; y++)
+ {
+ v3s16 p(x, y, z);
+ MapBlock *block = getBlockNoCreateNoEx(p);
+ block->heat_last_update = 0;
+ block->humidity_last_update = 0;
+ if (senv->m_use_weather) {
+ updateBlockHeat(senv, p * MAP_BLOCKSIZE, block);
+ updateBlockHumidity(senv, p * MAP_BLOCKSIZE, block);
+ } else {
+ block->heat = HEAT_UNDEFINED;
+ block->humidity = HUMIDITY_UNDEFINED;
+ }
+ }
+
#if 0
if(enable_mapgen_debug_info)
{
DSTACKF("%s: p2d=(%d,%d)",
__FUNCTION_NAME,
p2d.X, p2d.Y);
-
+
/*
Check if it exists already in memory
*/
ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
if(sector != NULL)
return sector;
-
+
/*
Try to load it from disk (with blocks)
*/
/*
Generate blank sector
*/
-
+
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;
}
+#if 0
/*
This is a quick-hand function for calling makeBlock().
*/
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);
-
+
/*infostream<<"generateBlock(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
-
+
bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
TimeTaker timer("generateBlock");
-
+
//MapBlock *block = original_dummy;
-
+
v2s16 p2d(p.X, p.Z);
v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
-
+
/*
Do not generate over-limit
*/
/*
Create block make data
*/
- mapgen::BlockMakeData data;
+ BlockMakeData data;
initBlockMake(&data, p);
/*
*/
{
TimeTaker t("mapgen::make_block()");
- mapgen::make_block(&data);
+ mapgen->makeChunk(&data);
+ //mapgen::make_block(&data);
if(enable_mapgen_debug_info == false)
t.stop(true); // Hide output
return block;
}
+#endif
MapBlock * ServerMap::createBlock(v3s16 p)
{
DSTACKF("%s: p=(%d,%d,%d)",
__FUNCTION_NAME, p.X, p.Y, p.Z);
-
+
/*
Do not create over-limit
*/
|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
throw InvalidPositionException("createBlock(): pos. over limit");
-
+
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
/*
}
// Create blank
block = sector->createBlankBlock(block_y);
+
return block;
}
-MapBlock * ServerMap::emergeBlock(v3s16 p, bool allow_generate)
+MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
{
- DSTACKF("%s: p=(%d,%d,%d), allow_generate=%d",
+ DSTACKF("%s: p=(%d,%d,%d), create_blank=%d",
__FUNCTION_NAME,
- p.X, p.Y, p.Z, allow_generate);
-
+ p.X, p.Y, p.Z, create_blank);
+
{
MapBlock *block = getBlockNoCreateNoEx(p);
if(block && block->isDummy() == false)
return block;
}
- if(allow_generate)
+ if (create_blank) {
+ ServerMapSector *sector = createSector(v2s16(p.X, p.Z));
+ MapBlock *block = sector->createBlankBlock(p.Y);
+
+ return block;
+ }
+ /*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
dispatchEvent(&event);
-
+
return block;
}
- }
+ }*/
return NULL;
}
-s16 ServerMap::findGroundLevel(v2s16 p2d)
-{
-#if 0
- /*
- Uh, just do something random...
- */
- // Find existing map from top to down
- s16 max=63;
- s16 min=-64;
- v3s16 p(p2d.X, max, p2d.Y);
- for(; p.Y>min; p.Y--)
- {
- MapNode n = getNodeNoEx(p);
- if(n.getContent() != CONTENT_IGNORE)
- break;
- }
- if(p.Y == min)
- goto plan_b;
- // If this node is not air, go to plan b
- if(getNodeNoEx(p).getContent() != CONTENT_AIR)
- goto plan_b;
- // Search existing walkable and return it
- for(; p.Y>min; p.Y--)
- {
- MapNode n = getNodeNoEx(p);
- if(content_walkable(n.d) && n.getContent() != CONTENT_IGNORE)
- return p.Y;
- }
+void ServerMap::prepareBlock(MapBlock *block) {
+ ServerEnvironment *senv = &((Server *)m_gamedef)->getEnv();
- // Move to plan b
-plan_b:
-#endif
+ // Calculate weather conditions
+ block->heat_last_update = 0;
+ block->humidity_last_update = 0;
+ if (senv->m_use_weather) {
+ v3s16 p = block->getPos() * MAP_BLOCKSIZE;
+ updateBlockHeat(senv, p, block);
+ updateBlockHumidity(senv, p, block);
+ } else {
+ block->heat = HEAT_UNDEFINED;
+ block->humidity = HUMIDITY_UNDEFINED;
+ }
+}
- /*
- Determine from map generator noise functions
- */
+/**
+ * Get the ground level by searching for a non CONTENT_AIR node in a column from top to bottom
+ */
+s16 ServerMap::findGroundLevel(v2s16 p2d, bool cacheBlocks)
+{
- s16 level = mapgen::find_ground_level_from_noise(m_seed, p2d, 1);
- return level;
+ s16 level;
- //double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
- //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";
-}
+ // The reference height is the original mapgen height
+ s16 referenceHeight = m_emerge->getGroundLevelAtPoint(p2d);
+ s16 maxSearchHeight = 63 + referenceHeight;
+ s16 minSearchHeight = -63 + referenceHeight;
+ v3s16 probePosition(p2d.X, maxSearchHeight, p2d.Y);
+ v3s16 blockPosition = getNodeBlockPos(probePosition);
+ v3s16 prevBlockPosition = blockPosition;
-void ServerMap::verifyDatabase() {
- if(m_database)
- return;
-
+ // Cache the block to be inspected.
+ if(cacheBlocks) {
+ emergeBlock(blockPosition, true);
+ }
+
+ // Probes the nodes in the given column
+ for(; probePosition.Y > minSearchHeight; probePosition.Y--)
{
- 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");
+ if(cacheBlocks) {
+ // Calculate the block position of the given node
+ blockPosition = getNodeBlockPos(probePosition);
+
+ // If the node is in an different block, cache it
+ if(blockPosition != prevBlockPosition) {
+ emergeBlock(blockPosition, true);
+ prevBlockPosition = blockPosition;
+ }
}
-
- 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");
+
+ MapNode node = getNodeNoEx(probePosition);
+ if (node.getContent() != CONTENT_IGNORE &&
+ node.getContent() != CONTENT_AIR) {
+ break;
}
-
- infostream<<"ServerMap: Database opened"<<std::endl;
}
+
+ // Could not determine the ground. Use map generator noise functions.
+ if(probePosition.Y == minSearchHeight) {
+ level = referenceHeight;
+ } else {
+ level = probePosition.Y;
+ }
+
+ return level;
}
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)
{
unsigned int x, y;
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;
infostream<<"WARNING: Not saving map, saving disabled."<<std::endl;
return;
}
-
+
if(save_level == MOD_STATE_CLEAN)
infostream<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
-
+
if(m_map_metadata_changed || save_level == MOD_STATE_CLEAN)
{
saveMapMeta();
// Profile modified reasons
Profiler modprofiler;
-
+
u32 sector_meta_count = 0;
u32 block_count = 0;
u32 block_count_all = 0; // Number of blocks in memory
-
+
// 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();
-
- while(sqlite3_step(m_database_list) == SQLITE_ROW)
+ MapSector *sector = si->second;
+
+ 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);
}
}
void ServerMap::saveMapMeta()
{
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::ofstream os(fullpath.c_str(), std::ios_base::binary);
- if(os.good() == false)
+ std::ostringstream ss(std::ios_base::binary);
+
+ Settings params;
+
+ m_emerge->setParamsToSettings(¶ms);
+ params.writeLines(ss);
+
+ ss<<"[end_of_params]\n";
+
+ if(!fs::safeWriteToFile(fullpath, ss.str()))
{
infostream<<"ERROR: ServerMap::saveMapMeta(): "
- <<"could not open"<<fullpath<<std::endl;
- throw FileNotGoodException("Cannot open chunk metadata");
+ <<"could not write "<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot save chunk metadata");
}
-
- Settings params;
- params.setU64("seed", m_seed);
- params.writeLines(os);
-
- os<<"[end_of_params]\n";
-
m_map_metadata_changed = false;
}
void ServerMap::loadMapMeta()
{
DSTACK(__FUNCTION_NAME);
-
+
/*infostream<<"ServerMap::loadMapMeta(): Loading map metadata"
<<std::endl;*/
break;
params.parseConfigLine(line);
}
-
- m_seed = params.getU64("seed");
+
+ MapgenParams *mgparams;
+ try {
+ mgparams = m_emerge->getParamsFromSettings(¶ms);
+ } catch (SettingNotFoundException &e) {
+ infostream << "Couldn't get a setting from map_meta.txt: "
+ << e.what() << std::endl;
+ mgparams = NULL;
+ }
+
+ if (mgparams) {
+ if (m_mgparams)
+ delete m_mgparams;
+ m_mgparams = mgparams;
+ m_seed = mgparams->seed;
+ } else {
+ if (params.exists("seed")) {
+ m_seed = read_seed(params.get("seed").c_str());
+ m_mgparams->seed = m_seed;
+ }
+ }
verbosestream<<"ServerMap::loadMapMeta(): "<<"seed="<<m_seed<<std::endl;
}
{
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);
+
+ if(!fs::safeWriteToFile(fullpath, ss.str()))
+ throw FileNotGoodException("Cannot write sector metafile");
- sector->serialize(o, version);
-
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
{
if(save_after_load)
saveSectorMeta(sector);
}
-
+
sector->differs_from_disk = false;
return sector;
{
return false;
}
-
+
return true;
}
{
return false;
}
-
+
/*
Load blocks
*/
#endif
void ServerMap::beginSave() {
- verifyDatabase();
- if(sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL) != SQLITE_OK)
- infostream<<"WARNING: beginSave() failed, saving might be slow.";
+ 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.";
+ dbase->endSave();
}
void 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;
- }
-
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST;
- // Get destination
- v3s16 p3d = block->getPos();
-
-
-#if 0
- v2s16 p2d(p3d.X, p3d.Z);
- std::string sectordir = getSectorDir(p2d);
-
- createDirs(sectordir);
-
- 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
- block->serialize(o, version, true);
-
- // Write block to database
-
- std::string tmp = o.str();
- const char *bytes = tmp.c_str();
-
- 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;
- 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;
- int written = sqlite3_step(m_database_write);
- if(written != SQLITE_DONE)
- infostream<<"WARNING: Block failed to save ("<<p3d.X<<", "<<p3d.Y<<", "<<p3d.Z<<") "
- <<sqlite3_errmsg(m_database)<<std::endl;
- // Make ready for later reuse
- sqlite3_reset(m_database_write);
-
- // We just wrote it to the disk so clear modified flag
- block->resetModified();
+ dbase->saveBlock(block);
}
void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load)
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
throw FileNotGoodException("Cannot open block file");
-
+
v3s16 p3d = getBlockPos(sectordir, blockfile);
v2s16 p2d(p3d.X, p3d.Z);
-
+
assert(sector->getPos() == p2d);
-
+
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
-
+
// Read basic data
block->deSerialize(is, version, true);
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
-
+
/*
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);
-
+
// Should be in database now, so delete the old file
fs::RecursiveDelete(fullpath);
}
-
+
// We just loaded it from the disk, so it's up-to-date.
block->resetModified();
<<" (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.
try {
std::istringstream is(*blob, std::ios_base::binary);
-
+
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
-
+
// Read basic data
block->deSerialize(is, version, true);
-
+
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
-
+
/*
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);
-
+
// We just loaded it from, so it's up-to-date.
block->resetModified();
}
catch(SerializationError &e)
{
- infostream<<"WARNING: Invalid block data in database "
- <<" (SerializationError). "
- <<"what()="<<e.what()
- <<std::endl;
- //" Ignoring. A new one will be generated.
- assert(0);
+ errorstream<<"Invalid block data in database"
+ <<" ("<<p3d.X<<","<<p3d.Y<<","<<p3d.Z<<")"
+ <<" (SerializationError): "<<e.what()<<std::endl;
- // TODO: Copy to a backup database.
+ // TODO: Block should be marked as invalid in memory so that it is
+ // not touched but the game can run
+
+ if(g_settings->getBool("ignore_world_load_errors")){
+ errorstream<<"Ignoring block load error. Duck and cover! "
+ <<"(ignore_world_load_errors)"<<std::endl;
+ } else {
+ throw SerializationError("Invalid block data in database");
+ //assert(0);
+ }
}
}
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);
-
- loadBlock(&datastr, blockpos, sector, false);
+ MapBlock *ret;
- 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) return (ret);
+ // Not found in database, try the files
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
loadlayout = 2;
sectordir = getSectorDir(p2d, 2);
}
-
+
/*
Make sure sector is loaded
*/
}
catch(InvalidFilenameException &e)
{
- return false;
+ return NULL;
}
catch(FileNotGoodException &e)
{
- return false;
+ return NULL;
}
catch(std::exception &e)
{
- return false;
+ return NULL;
}
}
-
+
/*
Make sure file exists
*/
out<<"ServerMap: ";
}
+s16 ServerMap::updateBlockHeat(ServerEnvironment *env, v3s16 p, MapBlock *block)
+{
+ u32 gametime = env->getGameTime();
+
+ if (block) {
+ if (gametime - block->heat_last_update < 10)
+ return block->heat;
+ } else {
+ block = getBlockNoCreateNoEx(getNodeBlockPos(p));
+ }
+
+ f32 heat = m_emerge->biomedef->calcBlockHeat(p, m_seed,
+ env->getTimeOfDayF(), gametime * env->getTimeOfDaySpeed());
+
+ if(block) {
+ block->heat = heat;
+ block->heat_last_update = gametime;
+ }
+ return heat;
+}
+
+s16 ServerMap::updateBlockHumidity(ServerEnvironment *env, v3s16 p, MapBlock *block)
+{
+ u32 gametime = env->getGameTime();
+
+ if (block) {
+ if (gametime - block->humidity_last_update < 10)
+ return block->humidity;
+ } else {
+ block = getBlockNoCreateNoEx(getNodeBlockPos(p));
+ }
+
+ f32 humidity = m_emerge->biomedef->calcBlockHumidity(p, m_seed,
+ env->getTimeOfDayF(), gametime * env->getTimeOfDaySpeed());
+
+ if(block) {
+ block->humidity = humidity;
+ block->humidity_last_update = gametime;
+ }
+ return humidity;
+}
+
/*
MapVoxelManipulator
*/
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;
try
{
<<" wanted area: ";
a.print(infostream);
infostream<<std::endl;*/
-
- MapBlock *block = m_map->getBlockNoCreate(p);
+
+ block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
else
if(block_data_inexistent)
{
+ flags |= VMANIP_BLOCK_DATA_INEXIST;
+
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++)
memset(&m_flags[i], VOXELFLAG_INEXISTENT, 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;
}
//infostream<<"emerge done"<<std::endl;
run on background.
*/
void MapVoxelManipulator::blitBack
- (core::map<v3s16, MapBlock*> & modified_blocks)
+ (std::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
*/
continue;
MapNode &n = m_data[m_area.index(p)];
-
+
v3s16 blockpos = getNodeBlockPos(p);
-
+
try
{
// Get block
blockpos_last = blockpos;
block_checked_in_modified = false;
}
-
+
// Calculate relative position in block
v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
//m_map->setNode(m_area.MinEdge + p, n);
block->setNode(relpos, n);
-
+
/*
Make sure block is in modified_blocks
*/
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);
VoxelArea block_area_nodes
(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
-
+
u32 size_MB = block_area_nodes.getVolume()*4/1000000;
if(size_MB >= 1)
{
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;
try
{
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_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);
+ }
}
}
+ /*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)
{
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)
+ bool existed = !(i->second & VMANIP_BLOCK_DATA_INEXIST);
+ if(existed == false)
{
- infostream<<"WARNING: "<<__FUNCTION_NAME
- <<": got NULL block "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<std::endl;
continue;
}
block->copyFrom(*this);
if(modified_blocks)
- modified_blocks->insert(p, block);
+ (*modified_blocks)[p] = block;
}
}
projects / dragonfireclient.git / blobdiff