minetest/src/map.cpp

3219 lines
77 KiB
C++
Raw Normal View History

2010-11-27 00:02:21 +01:00
/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
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
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 Lesser General Public License for more details.
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.
2010-11-27 00:02:21 +01:00
*/
#include "map.h"
2011-06-25 23:03:58 +02:00
#include "mapsector.h"
#include "mapblock.h"
2010-11-27 00:02:21 +01:00
#include "filesys.h"
#include "voxel.h"
#include "voxelalgorithms.h"
2010-12-22 02:33:58 +01:00
#include "porting.h"
#include "serialization.h"
2011-06-26 01:34:36 +02:00
#include "nodemetadata.h"
2011-10-12 12:53:38 +02:00
#include "settings.h"
#include "log.h"
#include "profiler.h"
2011-11-14 20:41:30 +01:00
#include "nodedef.h"
#include "gamedef.h"
#include "util/directiontables.h"
2013-07-28 22:10:44 +02:00
#include "util/mathconstants.h"
#include "rollback_interface.h"
#include "environment.h"
#include "emerge.h"
#include "mapgen_v6.h"
2014-11-01 18:16:23 +01:00
#include "mg_biome.h"
2013-09-10 18:16:36 +02:00
#include "config.h"
#include "server.h"
#include "database.h"
#include "database-dummy.h"
#include "database-sqlite3.h"
#include <deque>
#include <queue>
#if USE_LEVELDB
#include "database-leveldb.h"
#endif
2014-04-08 21:39:21 +02:00
#if USE_REDIS
#include "database-redis.h"
#endif
2016-05-14 11:00:42 +02:00
#if USE_POSTGRESQL
#include "database-postgresql.h"
#endif
2010-11-27 00:02:21 +01:00
#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
/*
Map
*/
Map::Map(std::ostream &dout, IGameDef *gamedef):
2010-11-27 00:02:21 +01:00
m_dout(dout),
m_gamedef(gamedef),
m_sector_cache(NULL),
m_transforming_liquid_loop_count_multiplier(1.0f),
m_unprocessed_count(0),
m_inc_trending_up_start_time(0),
m_queue_size_timer_started(false)
2010-11-27 00:02:21 +01:00
{
}
Map::~Map()
{
/*
2011-02-23 01:49:57 +01:00
Free all MapSectors
2010-11-27 00:02:21 +01:00
*/
2012-12-20 18:19:49 +01:00
for(std::map<v2s16, MapSector*>::iterator i = m_sectors.begin();
i != m_sectors.end(); ++i)
2010-11-27 00:02:21 +01:00
{
2012-12-20 18:19:49 +01:00
delete i->second;
2010-11-27 00:02:21 +01:00
}
}
2011-02-23 01:49:57 +01:00
void Map::addEventReceiver(MapEventReceiver *event_receiver)
{
2012-12-20 18:19:49 +01:00
m_event_receivers.insert(event_receiver);
2011-02-23 01:49:57 +01:00
}
void Map::removeEventReceiver(MapEventReceiver *event_receiver)
{
2012-12-20 18:19:49 +01:00
m_event_receivers.erase(event_receiver);
2011-02-23 01:49:57 +01:00
}
void Map::dispatchEvent(MapEditEvent *event)
{
2012-12-20 18:19:49 +01:00
for(std::set<MapEventReceiver*>::iterator
i = m_event_receivers.begin();
i != m_event_receivers.end(); ++i)
2011-02-23 01:49:57 +01:00
{
2012-12-20 18:19:49 +01:00
(*i)->onMapEditEvent(event);
2011-02-23 01:49:57 +01:00
}
}
MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
2010-11-27 00:02:21 +01:00
{
if(m_sector_cache != NULL && p == m_sector_cache_p){
MapSector * sector = m_sector_cache;
return sector;
}
2012-12-22 06:34:35 +01:00
2012-12-20 18:19:49 +01:00
std::map<v2s16, MapSector*>::iterator n = m_sectors.find(p);
2012-12-22 06:34:35 +01:00
2012-12-20 18:19:49 +01:00
if(n == m_sectors.end())
return NULL;
2012-12-22 06:34:35 +01:00
2012-12-20 18:19:49 +01:00
MapSector *sector = n->second;
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
// Cache the last result
m_sector_cache_p = p;
m_sector_cache = sector;
return sector;
}
MapSector * Map::getSectorNoGenerateNoEx(v2s16 p)
{
return getSectorNoGenerateNoExNoLock(p);
}
MapSector * Map::getSectorNoGenerate(v2s16 p)
{
MapSector *sector = getSectorNoGenerateNoEx(p);
if(sector == NULL)
throw InvalidPositionException();
2012-12-22 06:34:35 +01:00
return sector;
}
2010-12-21 17:08:24 +01:00
MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d)
{
2010-11-27 00:02:21 +01:00
v2s16 p2d(p3d.X, p3d.Z);
2011-06-26 00:31:43 +02:00
MapSector * sector = getSectorNoGenerateNoEx(p2d);
if(sector == NULL)
2010-12-21 17:08:24 +01:00
return NULL;
2011-06-25 23:03:58 +02:00
MapBlock *block = sector->getBlockNoCreateNoEx(p3d.Y);
2010-11-27 00:02:21 +01:00
return block;
2010-12-21 17:08:24 +01:00
}
2011-06-25 23:03:58 +02:00
MapBlock * Map::getBlockNoCreate(v3s16 p3d)
2012-12-22 06:34:35 +01:00
{
2011-06-25 23:03:58 +02:00
MapBlock *block = getBlockNoCreateNoEx(p3d);
if(block == NULL)
throw InvalidPositionException();
return block;
2010-12-21 17:08:24 +01:00
}
2010-11-27 00:02:21 +01:00
bool Map::isNodeUnderground(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
try{
MapBlock * block = getBlockNoCreate(blockpos);
return block->getIsUnderground();
}
catch(InvalidPositionException &e)
{
return false;
}
}
2011-06-26 01:34:36 +02:00
bool Map::isValidPosition(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
2011-06-26 01:34:36 +02:00
return (block != NULL);
}
// Returns a CONTENT_IGNORE node if not found
MapNode Map::getNodeNoEx(v3s16 p, bool *is_valid_position)
2011-06-26 01:34:36 +02:00
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if (block == NULL) {
if (is_valid_position != NULL)
*is_valid_position = false;
2011-06-26 01:34:36 +02:00
return MapNode(CONTENT_IGNORE);
}
2011-06-26 01:34:36 +02:00
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
bool is_valid_p;
MapNode node = block->getNodeNoCheck(relpos, &is_valid_p);
if (is_valid_position != NULL)
*is_valid_position = is_valid_p;
return node;
2011-06-26 01:34:36 +02:00
}
#if 0
// Deprecated
2011-06-26 01:34:36 +02:00
// throws InvalidPositionException if not found
// TODO: Now this is deprecated, getNodeNoEx should be renamed
2011-06-26 01:34:36 +02:00
MapNode Map::getNode(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if (block == NULL)
2011-06-26 01:34:36 +02:00
throw InvalidPositionException();
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
bool is_valid_position;
MapNode node = block->getNodeNoCheck(relpos, &is_valid_position);
if (!is_valid_position)
throw InvalidPositionException();
return node;
2011-06-26 01:34:36 +02:00
}
#endif
2011-06-26 01:34:36 +02:00
// throws InvalidPositionException if not found
void Map::setNode(v3s16 p, MapNode & n)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreate(blockpos);
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
// Never allow placing CONTENT_IGNORE, it fucks up stuff
if(n.getContent() == CONTENT_IGNORE){
bool temp_bool;
errorstream<<"Map::setNode(): Not allowing to place CONTENT_IGNORE"
<<" while trying to replace \""
<<m_gamedef->ndef()->get(block->getNodeNoCheck(relpos, &temp_bool)).name
<<"\" at "<<PP(p)<<" (block "<<PP(blockpos)<<")"<<std::endl;
debug_stacks_print_to(infostream);
return;
}
2011-06-26 01:34:36 +02:00
block->setNodeNoCheck(relpos, n);
}
2010-11-27 00:02:21 +01:00
/*
Goes recursively through the neighbours of the node.
Alters only transparent nodes.
If the lighting of the neighbour is lower than the lighting of
the node was (before changing it to 0 at the step before), the
lighting of the neighbour is set to 0 and then the same stuff
repeats for the neighbour.
The ending nodes of the routine are stored in light_sources.
This is useful when a light is removed. In such case, this
routine can be called for the light node and then again for
light_sources to re-light the area without the removed light.
values of from_nodes are lighting values.
*/
2010-12-18 16:46:00 +01:00
void Map::unspreadLight(enum LightBank bank,
2012-12-20 18:19:49 +01:00
std::map<v3s16, u8> & from_nodes,
std::set<v3s16> & light_sources,
std::map<v3s16, MapBlock*> & modified_blocks)
2010-11-27 00:02:21 +01:00
{
2011-11-14 20:41:30 +01:00
INodeDefManager *nodemgr = m_gamedef->ndef();
2010-11-27 00:02:21 +01:00
v3s16 dirs[6] = {
v3s16(0,0,1), // back
v3s16(0,1,0), // top
v3s16(1,0,0), // right
v3s16(0,0,-1), // front
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
};
2012-12-22 06:34:35 +01:00
if(from_nodes.empty())
2010-11-27 00:02:21 +01:00
return;
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
u32 blockchangecount = 0;
2012-12-20 18:19:49 +01:00
std::map<v3s16, u8> unlighted_nodes;
2010-11-27 00:02:21 +01:00
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
// Cache this a bit, too
bool block_checked_in_modified = false;
2012-12-22 06:34:35 +01:00
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, u8>::iterator j = from_nodes.begin();
j != from_nodes.end(); ++j)
2010-11-27 00:02:21 +01:00
{
2012-12-20 18:19:49 +01:00
v3s16 pos = j->first;
2010-11-27 00:02:21 +01:00
v3s16 blockpos = getNodeBlockPos(pos);
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
// Only fetch a new block if the block position has changed
try{
if(block == NULL || blockpos != blockpos_last){
block = getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
blockchangecount++;
}
}
catch(InvalidPositionException &e)
{
continue;
}
if(block->isDummy())
continue;
// Calculate relative position in block
2013-05-20 03:26:08 +02:00
//v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
2010-11-27 00:02:21 +01:00
// Get node straight from the block
2013-05-20 03:26:08 +02:00
//MapNode n = block->getNode(relpos);
2012-12-20 18:19:49 +01:00
u8 oldlight = j->second;
2010-11-27 00:02:21 +01:00
// Loop through 6 neighbors
for(u16 i=0; i<6; i++)
{
// Get the position of the neighbor node
v3s16 n2pos = pos + dirs[i];
2010-11-27 00:02:21 +01:00
// Get the block where the node is located
v3s16 blockpos, relpos;
getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
2010-11-27 00:02:21 +01:00
// Only fetch a new block if the block position has changed
try {
if(block == NULL || blockpos != blockpos_last){
block = getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
blockchangecount++;
2010-11-27 00:02:21 +01:00
}
}
catch(InvalidPositionException &e) {
continue;
}
// Get node straight from the block
bool is_valid_position;
MapNode n2 = block->getNode(relpos, &is_valid_position);
if (!is_valid_position)
continue;
bool changed = false;
2010-11-27 00:02:21 +01:00
//TODO: Optimize output by optimizing light_sources?
2010-11-27 00:02:21 +01:00
/*
If the neighbor is dimmer than what was specified
as oldlight (the light of the previous node)
*/
if(n2.getLight(bank, nodemgr) < oldlight)
{
2010-11-27 00:02:21 +01:00
/*
And the neighbor is transparent and it has some light
2010-11-27 00:02:21 +01:00
*/
if(nodemgr->get(n2).light_propagates
&& n2.getLight(bank, nodemgr) != 0)
2010-11-27 00:02:21 +01:00
{
/*
Set light to 0 and add to queue
2010-11-27 00:02:21 +01:00
*/
u8 current_light = n2.getLight(bank, nodemgr);
n2.setLight(bank, 0, nodemgr);
block->setNode(relpos, n2);
unlighted_nodes[n2pos] = current_light;
changed = true;
/*
Remove from light_sources if it is there
NOTE: This doesn't happen nearly at all
*/
/*if(light_sources.find(n2pos))
2010-11-27 00:02:21 +01:00
{
infostream<<"Removed from light_sources"<<std::endl;
light_sources.remove(n2pos);
}*/
2010-11-27 00:02:21 +01:00
}
/*// DEBUG
if(light_sources.find(n2pos) != NULL)
light_sources.remove(n2pos);*/
2010-11-27 00:02:21 +01:00
}
else{
light_sources.insert(n2pos);
}
// Add to modified_blocks
if(changed == true && block_checked_in_modified == false)
2010-11-27 00:02:21 +01:00
{
// If the block is not found in modified_blocks, add.
if(modified_blocks.find(blockpos) == modified_blocks.end())
{
modified_blocks[blockpos] = block;
}
block_checked_in_modified = true;
2010-11-27 00:02:21 +01:00
}
}
}
/*infostream<<"unspreadLight(): Changed block "
<<blockchangecount<<" times"
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
if(!unlighted_nodes.empty())
2010-12-18 16:46:00 +01:00
unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
2010-11-27 00:02:21 +01:00
}
/*
Lights neighbors of from_nodes, collects all them and then
goes on recursively.
*/
2010-12-18 16:46:00 +01:00
void Map::spreadLight(enum LightBank bank,
2012-12-20 18:19:49 +01:00
std::set<v3s16> & from_nodes,
std::map<v3s16, MapBlock*> & modified_blocks)
2010-11-27 00:02:21 +01:00
{
2011-11-14 20:41:30 +01:00
INodeDefManager *nodemgr = m_gamedef->ndef();
2010-11-27 00:02:21 +01:00
const v3s16 dirs[6] = {
v3s16(0,0,1), // back
v3s16(0,1,0), // top
v3s16(1,0,0), // right
v3s16(0,0,-1), // front
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
};
if(from_nodes.empty())
2010-11-27 00:02:21 +01:00
return;
2010-11-27 00:02:21 +01:00
u32 blockchangecount = 0;
2012-12-20 18:19:49 +01:00
std::set<v3s16> lighted_nodes;
2010-11-27 00:02:21 +01:00
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
// Cache this a bit, too
2010-11-27 00:02:21 +01:00
bool block_checked_in_modified = false;
2012-12-20 18:19:49 +01:00
for(std::set<v3s16>::iterator j = from_nodes.begin();
j != from_nodes.end(); ++j)
2010-11-27 00:02:21 +01:00
{
2012-12-20 18:19:49 +01:00
v3s16 pos = *j;
v3s16 blockpos, relpos;
getNodeBlockPosWithOffset(pos, blockpos, relpos);
2010-11-27 00:02:21 +01:00
// Only fetch a new block if the block position has changed
try {
2010-11-27 00:02:21 +01:00
if(block == NULL || blockpos != blockpos_last){
block = getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
blockchangecount++;
}
}
catch(InvalidPositionException &e) {
2010-11-27 00:02:21 +01:00
continue;
}
if(block->isDummy())
continue;
// Get node straight from the block
bool is_valid_position;
MapNode n = block->getNode(relpos, &is_valid_position);
2010-11-27 00:02:21 +01:00
u8 oldlight = is_valid_position ? n.getLight(bank, nodemgr) : 0;
2010-11-27 00:02:21 +01:00
u8 newlight = diminish_light(oldlight);
// Loop through 6 neighbors
for(u16 i=0; i<6; i++){
// Get the position of the neighbor node
v3s16 n2pos = pos + dirs[i];
2010-11-27 00:02:21 +01:00
// Get the block where the node is located
v3s16 blockpos, relpos;
getNodeBlockPosWithOffset(n2pos, blockpos, relpos);
2010-11-27 00:02:21 +01:00
// Only fetch a new block if the block position has changed
try {
if(block == NULL || blockpos != blockpos_last){
block = getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
blockchangecount++;
2010-11-27 00:02:21 +01:00
}
}
catch(InvalidPositionException &e) {
continue;
}
// Get node straight from the block
MapNode n2 = block->getNode(relpos, &is_valid_position);
if (!is_valid_position)
continue;
bool changed = false;
/*
If the neighbor is brighter than the current node,
add to list (it will light up this node on its turn)
*/
if(n2.getLight(bank, nodemgr) > undiminish_light(oldlight))
{
lighted_nodes.insert(n2pos);
changed = true;
}
/*
If the neighbor is dimmer than how much light this node
would spread on it, add to list
*/
if(n2.getLight(bank, nodemgr) < newlight)
{
if(nodemgr->get(n2).light_propagates)
2010-11-27 00:02:21 +01:00
{
n2.setLight(bank, newlight, nodemgr);
block->setNode(relpos, n2);
2012-12-20 18:19:49 +01:00
lighted_nodes.insert(n2pos);
2010-11-27 00:02:21 +01:00
changed = true;
}
}
2010-11-27 00:02:21 +01:00
// Add to modified_blocks
if(changed == true && block_checked_in_modified == false)
{
// If the block is not found in modified_blocks, add.
if(modified_blocks.find(blockpos) == modified_blocks.end())
2010-11-27 00:02:21 +01:00
{
modified_blocks[blockpos] = block;
2010-11-27 00:02:21 +01:00
}
block_checked_in_modified = true;
2010-11-27 00:02:21 +01:00
}
}
}
/*infostream<<"spreadLight(): Changed block "
2010-11-27 00:02:21 +01:00
<<blockchangecount<<" times"
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
if(!lighted_nodes.empty())
2010-12-18 16:46:00 +01:00
spreadLight(bank, lighted_nodes, modified_blocks);
2010-11-27 00:02:21 +01:00
}
2010-12-18 16:46:00 +01:00
void Map::updateLighting(enum LightBank bank,
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> & a_blocks,
std::map<v3s16, MapBlock*> & modified_blocks)
2010-11-27 00:02:21 +01:00
{
2011-11-14 20:41:30 +01:00
INodeDefManager *nodemgr = m_gamedef->ndef();
/*m_dout<<"Map::updateLighting(): "
2011-01-24 15:36:58 +01:00
<<a_blocks.size()<<" blocks."<<std::endl;*/
2011-01-24 15:36:58 +01:00
//TimeTaker timer("updateLighting");
2010-11-27 00:02:21 +01:00
// For debugging
//bool debug=true;
//u32 count_was = modified_blocks.size();
//std::map<v3s16, MapBlock*> blocks_to_update;
2010-11-27 00:02:21 +01:00
2012-12-20 18:19:49 +01:00
std::set<v3s16> light_sources;
2012-12-20 18:19:49 +01:00
std::map<v3s16, u8> unlight_from;
2012-01-27 12:24:06 +01:00
int num_bottom_invalid = 0;
2012-12-22 06:34:35 +01:00
{
2012-01-27 13:53:54 +01:00
//TimeTaker t("first stuff");
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator i = a_blocks.begin();
i != a_blocks.end(); ++i)
2010-11-27 00:02:21 +01:00
{
2012-12-20 18:19:49 +01:00
MapBlock *block = i->second;
2010-11-27 00:02:21 +01:00
for(;;)
{
// Don't bother with dummy blocks.
if(block->isDummy())
break;
2010-11-27 00:02:21 +01:00
v3s16 pos = block->getPos();
v3s16 posnodes = block->getPosRelative();
2012-12-20 18:19:49 +01:00
modified_blocks[pos] = block;
//blocks_to_update[pos] = block;
2010-11-27 00:02:21 +01:00
/*
Clear all light from block
*/
for(s16 z=0; z<MAP_BLOCKSIZE; z++)
for(s16 x=0; x<MAP_BLOCKSIZE; x++)
for(s16 y=0; y<MAP_BLOCKSIZE; y++)
{
v3s16 p(x,y,z);
bool is_valid_position;
MapNode n = block->getNode(p, &is_valid_position);
if (!is_valid_position) {
/* This would happen when dealing with a
dummy block.
2010-11-27 00:02:21 +01:00
*/
infostream<<"updateLighting(): InvalidPositionException"
2010-11-27 00:02:21 +01:00
<<std::endl;
continue;
}
u8 oldlight = n.getLight(bank, nodemgr);
n.setLight(bank, 0, nodemgr);
block->setNode(p, n);
// If node sources light, add to list
u8 source = nodemgr->get(n).light_source;
if(source != 0)
light_sources.insert(p + posnodes);
// Collect borders for unlighting
if((x==0 || x == MAP_BLOCKSIZE-1
|| y==0 || y == MAP_BLOCKSIZE-1
|| z==0 || z == MAP_BLOCKSIZE-1)
&& oldlight != 0)
{
v3s16 p_map = p + posnodes;
unlight_from[p_map] = oldlight;
2010-11-27 00:02:21 +01:00
}
2010-11-27 00:02:21 +01:00
}
2010-12-18 16:46:00 +01:00
if(bank == LIGHTBANK_DAY)
{
bool bottom_valid = block->propagateSunlight(light_sources);
2010-11-27 00:02:21 +01:00
2012-01-27 12:24:06 +01:00
if(!bottom_valid)
num_bottom_invalid++;
2010-12-18 16:46:00 +01:00
// If bottom is valid, we're done.
if(bottom_valid)
break;
}
else if(bank == LIGHTBANK_NIGHT)
{
// For night lighting, sunlight is not propagated
2010-11-27 00:02:21 +01:00
break;
2010-12-18 16:46:00 +01:00
}
else
{
assert("Invalid lighting bank" == NULL);
2010-12-18 16:46:00 +01:00
}
/*infostream<<"Bottom for sunlight-propagated block ("
2010-11-27 00:02:21 +01:00
<<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
<<std::endl;*/
// Bottom sunlight is not valid; get the block and loop to it
2010-11-27 00:02:21 +01:00
pos.Y--;
try{
block = getBlockNoCreate(pos);
}
catch(InvalidPositionException &e)
{
FATAL_ERROR("Invalid position");
2010-11-27 00:02:21 +01:00
}
2010-11-27 00:02:21 +01:00
}
}
}
2012-01-27 12:24:06 +01:00
2011-06-26 17:51:57 +02:00
/*
Enable this to disable proper lighting for speeding up map
generation for testing or whatever
*/
#if 0
2011-10-12 12:53:38 +02:00
//if(g_settings->get(""))
2011-06-26 17:51:57 +02:00
{
core::map<v3s16, MapBlock*>::Iterator i;
i = blocks_to_update.getIterator();
for(; i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
v3s16 p = block->getPos();
block->setLightingExpired(false);
}
return;
}
#endif
2011-01-24 15:36:58 +01:00
2012-01-27 03:02:42 +01:00
#if 1
2010-11-27 00:02:21 +01:00
{
2012-01-27 03:02:42 +01:00
//TimeTaker timer("unspreadLight");
2010-12-18 16:46:00 +01:00
unspreadLight(bank, unlight_from, light_sources, modified_blocks);
2010-11-27 00:02:21 +01:00
}
2012-01-27 03:02:42 +01:00
/*if(debug)
2010-11-27 00:02:21 +01:00
{
u32 diff = modified_blocks.size() - count_was;
count_was = modified_blocks.size();
infostream<<"unspreadLight modified "<<diff<<std::endl;
2012-01-27 03:02:42 +01:00
}*/
2010-11-27 00:02:21 +01:00
{
2012-01-27 03:02:42 +01:00
//TimeTaker timer("spreadLight");
2010-12-18 16:46:00 +01:00
spreadLight(bank, light_sources, modified_blocks);
2010-11-27 00:02:21 +01:00
}
2012-01-27 03:02:42 +01:00
/*if(debug)
2010-11-27 00:02:21 +01:00
{
u32 diff = modified_blocks.size() - count_was;
count_was = modified_blocks.size();
infostream<<"spreadLight modified "<<diff<<std::endl;
2012-01-27 03:02:42 +01:00
}*/
2011-01-24 15:36:58 +01:00
#endif
2012-01-27 03:02:42 +01:00
#if 0
2011-01-24 15:36:58 +01:00
{
//MapVoxelManipulator vmanip(this);
2012-12-22 06:34:35 +01:00
// Make a manual voxel manipulator and load all the blocks
// that touch the requested blocks
ManualMapVoxelManipulator vmanip(this);
2012-01-27 03:02:42 +01:00
{
//TimeTaker timer("initialEmerge");
2011-01-24 15:36:58 +01:00
core::map<v3s16, MapBlock*>::Iterator i;
i = blocks_to_update.getIterator();
2011-01-24 15:36:58 +01:00
for(; i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
v3s16 p = block->getPos();
// Add all surrounding blocks
2011-01-24 15:36:58 +01:00
vmanip.initialEmerge(p - v3s16(1,1,1), p + v3s16(1,1,1));
/*
Add all surrounding blocks that have up-to-date lighting
NOTE: This doesn't quite do the job (not everything
appropriate is lighted)
*/
/*for(s16 z=-1; z<=1; z++)
for(s16 y=-1; y<=1; y++)
for(s16 x=-1; x<=1; x++)
{
v3s16 p2 = p + v3s16(x,y,z);
MapBlock *block = getBlockNoCreateNoEx(p2);
if(block == NULL)
continue;
if(block->isDummy())
continue;
if(block->getLightingExpired())
continue;
vmanip.initialEmerge(p2, p2);
}*/
// Lighting of block will be updated completely
block->setLightingExpired(false);
2011-01-24 15:36:58 +01:00
}
2012-01-27 03:02:42 +01:00
}
2011-01-24 15:36:58 +01:00
{
2012-01-27 12:24:06 +01:00
//TimeTaker timer("unSpreadLight");
2011-11-14 20:41:30 +01:00
vmanip.unspreadLight(bank, unlight_from, light_sources, nodemgr);
2011-01-24 15:36:58 +01:00
}
{
2012-01-27 12:24:06 +01:00
//TimeTaker timer("spreadLight");
2011-11-14 20:41:30 +01:00
vmanip.spreadLight(bank, light_sources, nodemgr);
2011-01-24 15:36:58 +01:00
}
{
2012-01-27 12:24:06 +01:00
//TimeTaker timer("blitBack");
2011-01-24 15:36:58 +01:00
vmanip.blitBack(modified_blocks);
}
/*infostream<<"emerge_time="<<emerge_time<<std::endl;
2011-01-24 15:36:58 +01:00
emerge_time = 0;*/
}
2012-01-27 03:02:42 +01:00
#endif
2010-11-27 00:02:21 +01:00
//m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
}
2012-12-20 18:19:49 +01:00
void Map::updateLighting(std::map<v3s16, MapBlock*> & a_blocks,
std::map<v3s16, MapBlock*> & modified_blocks)
2010-12-18 16:46:00 +01:00
{
updateLighting(LIGHTBANK_DAY, a_blocks, modified_blocks);
updateLighting(LIGHTBANK_NIGHT, a_blocks, modified_blocks);
2010-12-19 15:51:45 +01:00
/*
Update information about whether day and night light differ
*/
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
2010-12-19 15:51:45 +01:00
{
2012-12-20 18:19:49 +01:00
MapBlock *block = i->second;
block->expireDayNightDiff();
2010-12-19 15:51:45 +01:00
}
2010-12-18 16:46:00 +01:00
}
2010-11-27 00:02:21 +01:00
void Map::addNodeAndUpdate(v3s16 p, MapNode n,
2013-11-23 15:35:49 +01:00
std::map<v3s16, MapBlock*> &modified_blocks,
bool remove_metadata)
2010-11-27 00:02:21 +01:00
{
INodeDefManager *ndef = m_gamedef->ndef();
2011-11-14 20:41:30 +01:00
// Collect old node for rollback
RollbackNode rollback_oldnode(this, p, m_gamedef);
2010-12-18 16:46:00 +01:00
// This is needed for updating the lighting
MapNode oldnode = getNodeNoEx(p);
2010-12-18 16:46:00 +01:00
// Remove node metadata
2013-11-23 15:35:49 +01:00
if (remove_metadata) {
removeNodeMetadata(p);
}
// Set the node on the map
// Ignore light (because calling voxalgo::update_lighting_nodes)
n.setLight(LIGHTBANK_DAY, 0, ndef);
n.setLight(LIGHTBANK_NIGHT, 0, ndef);
2010-11-27 00:02:21 +01:00
setNode(p, n);
2011-04-04 02:45:08 +02:00
// Update lighting
std::vector<std::pair<v3s16, MapNode> > oldnodes;
oldnodes.push_back(std::pair<v3s16, MapNode>(p, oldnode));
voxalgo::update_lighting_nodes(this, ndef, oldnodes, modified_blocks);
2010-11-27 00:02:21 +01:00
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
2010-12-19 15:51:45 +01:00
{
2012-12-20 18:19:49 +01:00
i->second->expireDayNightDiff();
2010-12-19 15:51:45 +01:00
}
// 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, if it was removed.)
*/
v3s16 dirs[7] = {
v3s16(0,0,1), // back
v3s16(0,1,0), // top
v3s16(1,0,0), // right
v3s16(0,0,-1), // front
v3s16(0,-1,0), // bottom
v3s16(-1,0,0), // left
v3s16(0,0,0), // self
};
for(u16 i=0; i<7; i++)
{
v3s16 p2 = p + dirs[i];
bool is_valid_position;
MapNode n2 = getNodeNoEx(p2, &is_valid_position);
if(is_valid_position
&& (ndef->get(n2).isLiquid() || n2.getContent() == CONTENT_AIR))
{
m_transforming_liquid.push_back(p2);
}
}
2010-11-27 00:02:21 +01:00
}
void Map::removeNodeAndUpdate(v3s16 p,
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> &modified_blocks)
2010-11-27 00:02:21 +01:00
{
addNodeAndUpdate(p, MapNode(CONTENT_AIR), modified_blocks, true);
2010-12-18 16:46:00 +01:00
}
2013-11-23 15:35:49 +01:00
bool Map::addNodeWithEvent(v3s16 p, MapNode n, bool remove_metadata)
2011-02-23 01:49:57 +01:00
{
MapEditEvent event;
2013-11-23 15:35:49 +01:00
event.type = remove_metadata ? MEET_ADDNODE : MEET_SWAPNODE;
2011-02-23 01:49:57 +01:00
event.p = p;
event.n = n;
bool succeeded = true;
try{
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> modified_blocks;
2013-11-23 15:35:49 +01:00
addNodeAndUpdate(p, n, modified_blocks, remove_metadata);
2011-02-23 01:49:57 +01:00
// Copy modified_blocks to event
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
2011-02-23 01:49:57 +01:00
{
2013-03-17 18:09:05 +01:00
event.modified_blocks.insert(i->first);
2011-02-23 01:49:57 +01:00
}
}
catch(InvalidPositionException &e){
succeeded = false;
}
dispatchEvent(&event);
return succeeded;
}
bool Map::removeNodeWithEvent(v3s16 p)
{
MapEditEvent event;
event.type = MEET_REMOVENODE;
event.p = p;
bool succeeded = true;
try{
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> modified_blocks;
2011-02-23 01:49:57 +01:00
removeNodeAndUpdate(p, modified_blocks);
// Copy modified_blocks to event
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
2011-02-23 01:49:57 +01:00
{
2013-03-17 18:09:05 +01:00
event.modified_blocks.insert(i->first);
2011-02-23 01:49:57 +01:00
}
}
catch(InvalidPositionException &e){
succeeded = false;
}
dispatchEvent(&event);
return succeeded;
}
bool Map::getDayNightDiff(v3s16 blockpos)
2010-12-19 15:51:45 +01:00
{
try{
v3s16 p = blockpos + v3s16(0,0,0);
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-19 15:51:45 +01:00
return true;
}
catch(InvalidPositionException &e){}
2010-12-21 17:08:24 +01:00
// Leading edges
2010-12-19 15:51:45 +01:00
try{
v3s16 p = blockpos + v3s16(-1,0,0);
2010-12-19 15:51:45 +01:00
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-19 15:51:45 +01:00
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,-1,0);
2010-12-19 15:51:45 +01:00
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-19 15:51:45 +01:00
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,0,-1);
2010-12-19 15:51:45 +01:00
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-19 15:51:45 +01:00
return true;
2010-11-27 00:02:21 +01:00
}
catch(InvalidPositionException &e){}
2010-12-21 17:08:24 +01:00
// Trailing edges
try{
v3s16 p = blockpos + v3s16(1,0,0);
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-21 17:08:24 +01:00
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,1,0);
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-21 17:08:24 +01:00
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,0,1);
MapBlock *b = getBlockNoCreate(p);
if(b->getDayNightDiff())
2010-12-21 17:08:24 +01:00
return true;
}
catch(InvalidPositionException &e){}
2010-12-19 15:51:45 +01:00
return false;
2010-11-27 00:02:21 +01:00
}
struct TimeOrderedMapBlock {
MapSector *sect;
MapBlock *block;
TimeOrderedMapBlock(MapSector *sect, MapBlock *block) :
sect(sect),
block(block)
{}
bool operator<(const TimeOrderedMapBlock &b) const
{
return block->getUsageTimer() < b.block->getUsageTimer();
};
};
2010-11-27 00:02:21 +01:00
/*
Updates usage timers
*/
void Map::timerUpdate(float dtime, float unload_timeout, u32 max_loaded_blocks,
std::vector<v3s16> *unloaded_blocks)
2010-11-27 00:02:21 +01:00
{
bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
2012-12-22 06:34:35 +01:00
// Profile modified reasons
Profiler modprofiler;
2012-12-22 06:34:35 +01:00
std::vector<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
u32 block_count_all = 0;
2010-11-27 00:02:21 +01:00
beginSave();
// If there is no practical limit, we spare creation of mapblock_queue
if (max_loaded_blocks == U32_MAX) {
for (std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
si != m_sectors.end(); ++si) {
MapSector *sector = si->second;
bool all_blocks_deleted = true;
2012-12-22 06:34:35 +01:00
MapBlockVect blocks;
sector->getBlocks(blocks);
2012-12-22 06:34:35 +01:00
for (MapBlockVect::iterator i = blocks.begin();
i != blocks.end(); ++i) {
MapBlock *block = (*i);
block->incrementUsageTimer(dtime);
if (block->refGet() == 0
&& block->getUsageTimer() > unload_timeout) {
v3s16 p = block->getPos();
// Save if modified
if (block->getModified() != MOD_STATE_CLEAN
&& save_before_unloading) {
modprofiler.add(block->getModifiedReasonString(), 1);
if (!saveBlock(block))
continue;
saved_blocks_count++;
}
// Delete from memory
sector->deleteBlock(block);
if (unloaded_blocks)
unloaded_blocks->push_back(p);
deleted_blocks_count++;
} else {
all_blocks_deleted = false;
block_count_all++;
}
}
if (all_blocks_deleted) {
sector_deletion_queue.push_back(si->first);
}
}
} else {
std::priority_queue<TimeOrderedMapBlock> mapblock_queue;
for (std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
si != m_sectors.end(); ++si) {
MapSector *sector = si->second;
MapBlockVect blocks;
sector->getBlocks(blocks);
for(MapBlockVect::iterator i = blocks.begin();
i != blocks.end(); ++i) {
MapBlock *block = (*i);
block->incrementUsageTimer(dtime);
mapblock_queue.push(TimeOrderedMapBlock(sector, block));
}
}
block_count_all = mapblock_queue.size();
// Delete old blocks, and blocks over the limit from the memory
while (!mapblock_queue.empty() && (mapblock_queue.size() > max_loaded_blocks
|| mapblock_queue.top().block->getUsageTimer() > unload_timeout)) {
TimeOrderedMapBlock b = mapblock_queue.top();
mapblock_queue.pop();
MapBlock *block = b.block;
if (block->refGet() != 0)
continue;
v3s16 p = block->getPos();
// Save if modified
if (block->getModified() != MOD_STATE_CLEAN && save_before_unloading) {
modprofiler.add(block->getModifiedReasonString(), 1);
if (!saveBlock(block))
continue;
saved_blocks_count++;
}
// Delete from memory
b.sect->deleteBlock(block);
if (unloaded_blocks)
unloaded_blocks->push_back(p);
deleted_blocks_count++;
block_count_all--;
}
// Delete empty sectors
for (std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
si != m_sectors.end(); ++si) {
if (si->second->empty()) {
sector_deletion_queue.push_back(si->first);
}
}
2010-11-27 00:02:21 +01:00
}
endSave();
2012-12-22 06:34:35 +01:00
// Finally delete the empty sectors
deleteSectors(sector_deletion_queue);
2012-12-22 06:34:35 +01:00
if(deleted_blocks_count != 0)
{
PrintInfo(infostream); // ServerMap/ClientMap:
infostream<<"Unloaded "<<deleted_blocks_count
<<" blocks from memory";
if(save_before_unloading)
infostream<<", of which "<<saved_blocks_count<<" were written";
infostream<<", "<<block_count_all<<" blocks in memory";
infostream<<"."<<std::endl;
if(saved_blocks_count != 0){
PrintInfo(infostream); // ServerMap/ClientMap:
infostream<<"Blocks modified by: "<<std::endl;
modprofiler.print(infostream);
}
2010-11-27 00:02:21 +01:00
}
}
void Map::unloadUnreferencedBlocks(std::vector<v3s16> *unloaded_blocks)
{
timerUpdate(0.0, -1.0, 0, unloaded_blocks);
}
void Map::deleteSectors(std::vector<v2s16> &sectorList)
2010-11-27 00:02:21 +01:00
{
for(std::vector<v2s16>::iterator j = sectorList.begin();
j != sectorList.end(); ++j) {
2010-11-27 00:02:21 +01:00
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
2012-12-20 18:19:49 +01:00
m_sectors.erase(*j);
delete sector;
2010-11-27 00:02:21 +01:00
}
}
void Map::PrintInfo(std::ostream &out)
{
out<<"Map: ";
}
#define WATER_DROP_BOOST 4
enum NeighborType {
NEIGHBOR_UPPER,
NEIGHBOR_SAME_LEVEL,
NEIGHBOR_LOWER
};
struct NodeNeighbor {
MapNode n;
NeighborType t;
v3s16 p;
2013-02-24 15:39:07 +01:00
bool l; //can liquid
NodeNeighbor()
: n(CONTENT_AIR)
{ }
NodeNeighbor(const MapNode &node, NeighborType n_type, v3s16 pos)
: n(node),
t(n_type),
p(pos)
{ }
};
2013-02-24 15:39:07 +01:00
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)
{
2011-11-14 20:41:30 +01:00
INodeDefManager *nodemgr = m_gamedef->ndef();
DSTACK(FUNCTION_NAME);
2011-01-17 20:18:08 +01:00
//TimeTaker timer("transformLiquids()");
u32 loopcount = 0;
u32 initial_size = m_transforming_liquid.size();
2011-02-08 00:12:55 +01:00
/*if(initial_size != 0)
infostream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
2011-08-16 19:56:57 +02:00
// list of nodes that due to viscosity have not reached their max level height
std::deque<v3s16> must_reflow;
2012-12-22 06:34:35 +01:00
std::vector<std::pair<v3s16, MapNode> > changed_nodes;
2011-08-16 19:56:57 +02:00
u32 liquid_loop_max = g_settings->getS32("liquid_loop_max");
u32 loop_max = liquid_loop_max;
#if 0
/* If liquid_loop_max is not keeping up with the queue size increase
* loop_max up to a maximum of liquid_loop_max * dedicated_server_step.
*/
if (m_transforming_liquid.size() > loop_max * 2) {
// "Burst" mode
float server_step = g_settings->getFloat("dedicated_server_step");
if (m_transforming_liquid_loop_count_multiplier - 1.0 < server_step)
m_transforming_liquid_loop_count_multiplier *= 1.0 + server_step / 10;
} else {
m_transforming_liquid_loop_count_multiplier = 1.0;
}
loop_max *= m_transforming_liquid_loop_count_multiplier;
#endif
while (m_transforming_liquid.size() != 0)
{
2011-08-15 17:49:44 +02:00
// This should be done here so that it is done when continue is used
if (loopcount >= initial_size || loopcount >= loop_max)
2011-08-15 17:49:44 +02:00
break;
loopcount++;
2011-01-23 16:29:15 +01:00
/*
Get a queued transforming liquid node
*/
v3s16 p0 = m_transforming_liquid.front();
m_transforming_liquid.pop_front();
MapNode n0 = getNodeNoEx(p0);
/*
Collect information about current node
*/
s8 liquid_level = -1;
2016-10-25 23:04:10 +02:00
// The liquid node which will be placed there if
// the liquid flows into this node.
content_t liquid_kind = CONTENT_IGNORE;
2016-10-25 23:04:10 +02:00
// The node which will be placed there if liquid
// can't flow into this node.
content_t floodable_node = CONTENT_AIR;
const ContentFeatures &cf = nodemgr->get(n0);
LiquidType liquid_type = cf.liquid_type;
switch (liquid_type) {
case LIQUID_SOURCE:
2011-08-16 08:31:33 +02:00
liquid_level = LIQUID_LEVEL_SOURCE;
liquid_kind = nodemgr->getId(cf.liquid_alternative_flowing);
break;
case LIQUID_FLOWING:
liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
liquid_kind = n0.getContent();
break;
case LIQUID_NONE:
// if this node is 'floodable', it *could* be transformed
// into a liquid, otherwise, continue with the next node.
if (!cf.floodable)
continue;
floodable_node = n0.getContent();
liquid_kind = CONTENT_AIR;
break;
}
/*
Collect information about the environment
*/
const v3s16 *dirs = g_6dirs;
NodeNeighbor sources[6]; // surrounding sources
int num_sources = 0;
NodeNeighbor flows[6]; // surrounding flowing liquid nodes
int num_flows = 0;
NodeNeighbor airs[6]; // surrounding air
int num_airs = 0;
NodeNeighbor neutrals[6]; // nodes that are solid or another kind of liquid
int num_neutrals = 0;
bool flowing_down = false;
for (u16 i = 0; i < 6; i++) {
NeighborType nt = NEIGHBOR_SAME_LEVEL;
switch (i) {
case 1:
nt = NEIGHBOR_UPPER;
break;
case 4:
nt = NEIGHBOR_LOWER;
break;
}
v3s16 npos = p0 + dirs[i];
NodeNeighbor nb(getNodeNoEx(npos), nt, npos);
const ContentFeatures &cfnb = nodemgr->get(nb.n);
2011-11-14 20:41:30 +01:00
switch (nodemgr->get(nb.n.getContent()).liquid_type) {
case LIQUID_NONE:
if (cfnb.floodable) {
airs[num_airs++] = nb;
// if the current node is a water source the neighbor
// should be enqueded for transformation regardless of whether the
// current node changes or not.
if (nb.t != NEIGHBOR_UPPER && liquid_type != LIQUID_NONE)
m_transforming_liquid.push_back(npos);
// if the current node happens to be a flowing node, it will start to flow down here.
if (nb.t == NEIGHBOR_LOWER)
flowing_down = true;
} else {
neutrals[num_neutrals++] = nb;
// If neutral below is ignore prevent water spreading outwards
if (nb.t == NEIGHBOR_LOWER &&
nb.n.getContent() == CONTENT_IGNORE)
flowing_down = true;
}
break;
case LIQUID_SOURCE:
2012-12-22 06:34:35 +01:00
// 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(cfnb.liquid_alternative_flowing);
if (nodemgr->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
neutrals[num_neutrals++] = nb;
} else {
// Do not count bottom source, it will screw things up
if(dirs[i].Y != -1)
sources[num_sources++] = nb;
}
break;
case LIQUID_FLOWING:
// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
2011-07-17 13:15:33 +02:00
if (liquid_kind == CONTENT_AIR)
liquid_kind = nodemgr->getId(cfnb.liquid_alternative_flowing);
if (nodemgr->getId(cfnb.liquid_alternative_flowing) != liquid_kind) {
neutrals[num_neutrals++] = nb;
} else {
flows[num_flows++] = nb;
if (nb.t == NEIGHBOR_LOWER)
flowing_down = true;
}
break;
}
}
/*
decide on the type (and possibly level) of the current node
*/
content_t new_node_content;
s8 new_node_level = -1;
2011-08-16 19:56:57 +02:00
s8 max_node_level = -1;
u8 range = nodemgr->get(liquid_kind).liquid_range;
if (range > LIQUID_LEVEL_MAX + 1)
range = LIQUID_LEVEL_MAX + 1;
2012-09-07 18:48:12 +02:00
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);
2012-09-07 18:48:12 +02:00
} else if (num_sources >= 1 && sources[0].t != NEIGHBOR_LOWER) {
// liquid_kind is set properly, see above
2011-08-16 19:56:57 +02:00
max_node_level = new_node_level = LIQUID_LEVEL_MAX;
if (new_node_level >= (LIQUID_LEVEL_MAX + 1 - range))
new_node_content = liquid_kind;
else
new_node_content = floodable_node;
} else {
// no surrounding sources, so get the maximum level that can flow into this node
for (u16 i = 0; i < num_flows; i++) {
u8 nb_liquid_level = (flows[i].n.param2 & LIQUID_LEVEL_MASK);
switch (flows[i].t) {
case NEIGHBOR_UPPER:
2011-08-16 19:56:57 +02:00
if (nb_liquid_level + WATER_DROP_BOOST > max_node_level) {
max_node_level = LIQUID_LEVEL_MAX;
2011-08-16 08:31:33 +02:00
if (nb_liquid_level + WATER_DROP_BOOST < LIQUID_LEVEL_MAX)
2011-08-16 19:56:57 +02:00
max_node_level = nb_liquid_level + WATER_DROP_BOOST;
} else if (nb_liquid_level > max_node_level) {
max_node_level = nb_liquid_level;
}
break;
case NEIGHBOR_LOWER:
break;
case NEIGHBOR_SAME_LEVEL:
if ((flows[i].n.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK &&
nb_liquid_level > 0 && nb_liquid_level - 1 > max_node_level)
2011-08-16 19:56:57 +02:00
max_node_level = nb_liquid_level - 1;
break;
}
}
2011-11-14 20:41:30 +01:00
u8 viscosity = nodemgr->get(liquid_kind).liquid_viscosity;
2011-08-16 20:38:44 +02:00
if (viscosity > 1 && max_node_level != liquid_level) {
2011-08-16 19:56:57 +02:00
// amount to gain, limited by viscosity
// must be at least 1 in absolute value
s8 level_inc = max_node_level - liquid_level;
if (level_inc < -viscosity || level_inc > viscosity)
new_node_level = liquid_level + level_inc/viscosity;
else if (level_inc < 0)
new_node_level = liquid_level - 1;
else if (level_inc > 0)
new_node_level = liquid_level + 1;
if (new_node_level != max_node_level)
must_reflow.push_back(p0);
} else {
2011-08-16 19:56:57 +02:00
new_node_level = max_node_level;
}
2011-08-16 19:56:57 +02:00
if (max_node_level >= (LIQUID_LEVEL_MAX + 1 - range))
new_node_content = liquid_kind;
else
new_node_content = floodable_node;
2011-08-16 19:56:57 +02:00
}
/*
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.param2 & LIQUID_LEVEL_MASK) == (u8)new_node_level &&
((n0.param2 & LIQUID_FLOW_DOWN_MASK) == LIQUID_FLOW_DOWN_MASK)
== flowing_down)))
continue;
/*
update the current node
*/
MapNode n00 = n0;
//bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
2011-11-14 20:41:30 +01:00
if (nodemgr->get(new_node_content).liquid_type == LIQUID_FLOWING) {
// set level to last 3 bits, flowing down bit to 4th bit
n0.param2 = (flowing_down ? LIQUID_FLOW_DOWN_MASK : 0x00) | (new_node_level & LIQUID_LEVEL_MASK);
} else {
// set the liquid level and flow bit to 0
n0.param2 = ~(LIQUID_LEVEL_MASK | LIQUID_FLOW_DOWN_MASK);
}
n0.setContent(new_node_content);
2012-12-22 06:34:35 +01:00
// Ignore light (because calling voxalgo::update_lighting_nodes)
n0.setLight(LIGHTBANK_DAY, 0, nodemgr);
n0.setLight(LIGHTBANK_NIGHT, 0, nodemgr);
// Find out whether there is a suspect for this action
std::string suspect;
if (m_gamedef->rollback())
2012-07-27 14:46:51 +02:00
suspect = m_gamedef->rollback()->getSuspect(p0, 83, 1);
if (m_gamedef->rollback() && !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) {
2012-12-20 18:19:49 +01:00
modified_blocks[blockpos] = block;
changed_nodes.push_back(std::pair<v3s16, MapNode>(p0, n00));
2011-08-22 12:19:07 +02:00
}
/*
enqueue neighbors for update if neccessary
*/
2011-11-14 20:41:30 +01:00
switch (nodemgr->get(n0.getContent()).liquid_type) {
case LIQUID_SOURCE:
case LIQUID_FLOWING:
// make sure source flows into all neighboring nodes
for (u16 i = 0; i < num_flows; i++)
if (flows[i].t != NEIGHBOR_UPPER)
m_transforming_liquid.push_back(flows[i].p);
for (u16 i = 0; i < num_airs; i++)
if (airs[i].t != NEIGHBOR_UPPER)
m_transforming_liquid.push_back(airs[i].p);
break;
case LIQUID_NONE:
// this flow has turned to air; neighboring flows might need to do the same
for (u16 i = 0; i < num_flows; i++)
m_transforming_liquid.push_back(flows[i].p);
break;
}
}
//infostream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
for (std::deque<v3s16>::iterator iter = must_reflow.begin(); iter != must_reflow.end(); ++iter)
m_transforming_liquid.push_back(*iter);
voxalgo::update_lighting_nodes(this, nodemgr, changed_nodes, modified_blocks);
/* ----------------------------------------------------------------------
* Manage the queue so that it does not grow indefinately
*/
u16 time_until_purge = g_settings->getU16("liquid_queue_purge_time");
if (time_until_purge == 0)
return; // Feature disabled
time_until_purge *= 1000; // seconds -> milliseconds
u32 curr_time = getTime(PRECISION_MILLI);
u32 prev_unprocessed = m_unprocessed_count;
m_unprocessed_count = m_transforming_liquid.size();
// if unprocessed block count is decreasing or stable
if (m_unprocessed_count <= prev_unprocessed) {
m_queue_size_timer_started = false;
} else {
if (!m_queue_size_timer_started)
m_inc_trending_up_start_time = curr_time;
m_queue_size_timer_started = true;
}
// Account for curr_time overflowing
if (m_queue_size_timer_started && m_inc_trending_up_start_time > curr_time)
m_queue_size_timer_started = false;
/* If the queue has been growing for more than liquid_queue_purge_time seconds
* and the number of unprocessed blocks is still > liquid_loop_max then we
* cannot keep up; dump the oldest blocks from the queue so that the queue
* has liquid_loop_max items in it
*/
if (m_queue_size_timer_started
&& curr_time - m_inc_trending_up_start_time > time_until_purge
&& m_unprocessed_count > liquid_loop_max) {
size_t dump_qty = m_unprocessed_count - liquid_loop_max;
infostream << "transformLiquids(): DUMPING " << dump_qty
<< " blocks from the queue" << std::endl;
while (dump_qty--)
m_transforming_liquid.pop_front();
m_queue_size_timer_started = false; // optimistically assume we can keep up now
m_unprocessed_count = m_transforming_liquid.size();
}
}
std::vector<v3s16> Map::findNodesWithMetadata(v3s16 p1, v3s16 p2)
{
std::vector<v3s16> positions_with_meta;
sortBoxVerticies(p1, p2);
v3s16 bpmin = getNodeBlockPos(p1);
v3s16 bpmax = getNodeBlockPos(p2);
VoxelArea area(p1, p2);
for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
for (s16 y = bpmin.Y; y <= bpmax.Y; y++)
for (s16 x = bpmin.X; x <= bpmax.X; x++) {
v3s16 blockpos(x, y, z);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if (!block) {
verbosestream << "Map::getNodeMetadata(): Need to emerge "
<< PP(blockpos) << std::endl;
block = emergeBlock(blockpos, false);
}
if (!block) {
infostream << "WARNING: Map::getNodeMetadata(): Block not found"
<< std::endl;
continue;
}
v3s16 p_base = blockpos * MAP_BLOCKSIZE;
std::vector<v3s16> keys = block->m_node_metadata.getAllKeys();
for (size_t i = 0; i != keys.size(); i++) {
v3s16 p(keys[i] + p_base);
if (!area.contains(p))
continue;
positions_with_meta.push_back(p);
}
}
return positions_with_meta;
}
NodeMetadata *Map::getNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(!block){
infostream<<"Map::getNodeMetadata(): Need to emerge "
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
if(!block){
warningstream<<"Map::getNodeMetadata(): Block not found"
2011-04-04 02:45:08 +02:00
<<std::endl;
return NULL;
2011-04-04 02:45:08 +02:00
}
2012-03-19 01:08:04 +01:00
NodeMetadata *meta = block->m_node_metadata.get(p_rel);
return meta;
}
bool Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
2011-04-04 02:45:08 +02:00
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(!block){
infostream<<"Map::setNodeMetadata(): Need to emerge "
<<PP(blockpos)<<std::endl;
block = emergeBlock(blockpos, false);
}
if(!block){
warningstream<<"Map::setNodeMetadata(): Block not found"
2011-04-04 02:45:08 +02:00
<<std::endl;
return false;
2011-04-04 02:45:08 +02:00
}
2012-03-19 01:08:04 +01:00
block->m_node_metadata.set(p_rel, meta);
return true;
2011-04-04 02:45:08 +02:00
}
void Map::removeNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
{
warningstream<<"Map::removeNodeMetadata(): Block not found"
2011-04-04 02:45:08 +02:00
<<std::endl;
return;
}
2012-03-19 01:08:04 +01:00
block->m_node_metadata.remove(p_rel);
2011-04-05 01:56:29 +02:00
}
2012-07-17 15:00:04 +02:00
NodeTimer Map::getNodeTimer(v3s16 p)
{
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){
warningstream<<"Map::getNodeTimer(): Block not found"
2012-07-17 15:00:04 +02:00
<<std::endl;
return NodeTimer();
}
NodeTimer t = block->m_node_timers.get(p_rel);
2016-03-21 12:58:52 +01:00
NodeTimer nt(t.timeout, t.elapsed, p);
return nt;
2012-07-17 15:00:04 +02:00
}
2016-03-21 12:58:52 +01:00
void Map::setNodeTimer(const NodeTimer &t)
2012-07-17 15:00:04 +02:00
{
2016-03-21 12:58:52 +01:00
v3s16 p = t.position;
2012-07-17 15:00:04 +02:00
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){
warningstream<<"Map::setNodeTimer(): Block not found"
2012-07-17 15:00:04 +02:00
<<std::endl;
return;
}
2016-03-21 12:58:52 +01:00
NodeTimer nt(t.timeout, t.elapsed, p_rel);
block->m_node_timers.set(nt);
2012-07-17 15:00:04 +02:00
}
void Map::removeNodeTimer(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
{
warningstream<<"Map::removeNodeTimer(): Block not found"
2012-07-17 15:00:04 +02:00
<<std::endl;
return;
}
block->m_node_timers.remove(p_rel);
}
2010-11-27 00:02:21 +01:00
/*
ServerMap
*/
ServerMap::ServerMap(std::string savedir, IGameDef *gamedef, EmergeManager *emerge):
Map(dout_server, gamedef),
settings_mgr(g_settings, savedir + DIR_DELIM + "map_meta.txt"),
m_emerge(emerge),
m_map_metadata_changed(true)
2010-11-27 00:02:21 +01:00
{
verbosestream<<FUNCTION_NAME<<std::endl;
// Tell the EmergeManager about our MapSettingsManager
emerge->map_settings_mgr = &settings_mgr;
/*
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
conf.set("backend", "sqlite3");
}
std::string backend = conf.get("backend");
2015-02-27 08:24:07 +01:00
dbase = createDatabase(backend, savedir, conf);
if (!conf.updateConfigFile(conf_path.c_str()))
errorstream << "ServerMap::ServerMap(): Failed to update world.mt!" << std::endl;
2010-11-27 00:02:21 +01:00
m_savedir = savedir;
m_map_saving_enabled = false;
2010-11-27 00:02:21 +01:00
try
{
// If directory exists, check contents and load if possible
if(fs::PathExists(m_savedir))
{
// If directory is empty, it is safe to save into it.
if(fs::GetDirListing(m_savedir).size() == 0)
{
2012-03-11 03:15:45 +01:00
infostream<<"ServerMap: Empty save directory is valid."
2010-11-27 00:02:21 +01:00
<<std::endl;
m_map_saving_enabled = true;
}
else
{
if (settings_mgr.loadMapMeta()) {
infostream << "ServerMap: Metadata loaded from "
<< savedir << std::endl;
} else {
infostream << "ServerMap: Metadata could not be loaded "
"from " << savedir << ", assuming valid save "
"directory." << std::endl;
}
2010-11-27 00:02:21 +01:00
m_map_saving_enabled = true;
// Map loaded, not creating new one
return;
}
}
// If directory doesn't exist, it is safe to save to it
else{
m_map_saving_enabled = true;
}
}
catch(std::exception &e)
{
warningstream<<"ServerMap: Failed to load map from "<<savedir
2010-11-27 00:02:21 +01:00
<<", exception: "<<e.what()<<std::endl;
infostream<<"Please remove the map or fix it."<<std::endl;
warningstream<<"Map saving will be disabled."<<std::endl;
2010-11-27 00:02:21 +01:00
}
infostream<<"Initializing new map."<<std::endl;
2010-11-27 00:02:21 +01:00
// Create zero sector
emergeSector(v2s16(0,0));
// Initially write whole map
save(MOD_STATE_CLEAN);
2010-11-27 00:02:21 +01:00
}
ServerMap::~ServerMap()
{
verbosestream<<FUNCTION_NAME<<std::endl;
2010-11-27 00:02:21 +01:00
try
{
if(m_map_saving_enabled)
{
// Save only changed parts
save(MOD_STATE_WRITE_AT_UNLOAD);
2012-03-11 03:15:45 +01:00
infostream<<"ServerMap: Saved map to "<<m_savedir<<std::endl;
2010-11-27 00:02:21 +01:00
}
else
{
2012-03-11 03:15:45 +01:00
infostream<<"ServerMap: Map not saved"<<std::endl;
2010-11-27 00:02:21 +01:00
}
}
catch(std::exception &e)
{
2012-03-11 03:15:45 +01:00
infostream<<"ServerMap: Failed to save map to "<<m_savedir
2010-11-27 00:02:21 +01:00
<<", exception: "<<e.what()<<std::endl;
}
/*
Close database if it was opened
*/
delete dbase;
#if 0
/*
Free all MapChunks
*/
core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
for(; i.atEnd() == false; i++)
{
MapChunk *chunk = i.getNode()->getValue();
delete chunk;
}
#endif
}
MapgenParams *ServerMap::getMapgenParams()
{
// getMapgenParams() should only ever be called after Server is initialized
assert(settings_mgr.mapgen_params != NULL);
return settings_mgr.mapgen_params;
}
u64 ServerMap::getSeed()
{
return getMapgenParams()->seed;
}
2013-04-07 21:01:19 +02:00
s16 ServerMap::getWaterLevel()
{
return getMapgenParams()->water_level;
2010-11-27 00:02:21 +01:00
}
bool ServerMap::initBlockMake(v3s16 blockpos, BlockMakeData *data)
{
s16 csize = getMapgenParams()->chunksize;
v3s16 bpmin = EmergeManager::getContainingChunk(blockpos, csize);
v3s16 bpmax = bpmin + v3s16(1, 1, 1) * (csize - 1);
bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
EMERGE_DBG_OUT("initBlockMake(): " PP(bpmin) " - " PP(bpmax));
2012-02-03 01:23:21 +01:00
v3s16 extra_borders(1, 1, 1);
v3s16 full_bpmin = bpmin - extra_borders;
v3s16 full_bpmax = bpmax + extra_borders;
2012-02-03 01:23:21 +01:00
// Do nothing if not inside limits (+-1 because of neighbors)
if (blockpos_over_limit(full_bpmin) ||
blockpos_over_limit(full_bpmax))
2013-02-17 08:46:08 +01:00
return false;
2012-12-22 06:34:35 +01:00
data->seed = getSeed();
data->blockpos_min = bpmin;
data->blockpos_max = bpmax;
data->blockpos_requested = blockpos;
data->nodedef = m_gamedef->ndef();
2011-01-15 12:50:13 +01:00
/*
Create the whole area of this and the neighboring blocks
*/
for (s16 x = full_bpmin.X; x <= full_bpmax.X; x++)
for (s16 z = full_bpmin.Z; z <= full_bpmax.Z; z++) {
v2s16 sectorpos(x, z);
// Sector metadata is loaded from disk if not already loaded.
ServerMapSector *sector = createSector(sectorpos);
FATAL_ERROR_IF(sector == NULL, "createSector() failed");
for (s16 y = full_bpmin.Y; y <= full_bpmax.Y; y++) {
v3s16 p(x, y, z);
MapBlock *block = emergeBlock(p, false);
if (block == NULL) {
block = createBlock(p);
2011-01-08 13:08:48 +01:00
// Block gets sunlight if this is true.
// Refer to the map generator heuristics.
bool ug = m_emerge->isBlockUnderground(p);
block->setIsUnderground(ug);
2011-01-08 13:08:48 +01:00
}
2010-12-25 15:04:51 +01:00
}
}
2012-12-22 06:34:35 +01:00
2011-01-15 12:50:13 +01:00
/*
Now we have a big empty area.
Make a ManualMapVoxelManipulator that contains this and the
neighboring blocks
2011-01-15 12:50:13 +01:00
*/
2012-12-22 06:34:35 +01:00
data->vmanip = new MMVManip(this);
data->vmanip->initialEmerge(full_bpmin, full_bpmax);
2011-01-15 12:50:13 +01:00
// Note: we may need this again at some point.
#if 0
// 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++) {
2013-02-17 07:47:49 +01:00
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);
}
}
}
#endif
2010-12-13 02:19:12 +01:00
// Data is ready now.
2013-02-17 08:46:08 +01:00
return true;
}
void ServerMap::finishBlockMake(BlockMakeData *data,
std::map<v3s16, MapBlock*> *changed_blocks)
{
v3s16 bpmin = data->blockpos_min;
v3s16 bpmax = data->blockpos_max;
v3s16 extra_borders(1, 1, 1);
v3s16 full_bpmin = bpmin - extra_borders;
v3s16 full_bpmax = bpmax + extra_borders;
2012-02-03 01:23:21 +01:00
bool enable_mapgen_debug_info = m_emerge->enable_mapgen_debug_info;
EMERGE_DBG_OUT("finishBlockMake(): " PP(bpmin) " - " PP(bpmax));
/*
Set lighting to non-expired state in all of them.
This is cheating, but it is not fast enough if all of them
would actually be updated.
*/
for (s16 x = full_bpmin.X; x <= full_bpmax.X; x++)
for (s16 z = full_bpmin.Z; z <= full_bpmax.Z; z++)
for (s16 y = full_bpmin.Y; y <= full_bpmax.Y; y++) {
MapBlock *block = emergeBlock(v3s16(x, y, z), false);
if (!block)
continue;
block->setLightingExpired(false);
}
2010-11-27 00:02:21 +01:00
/*
Blit generated stuff to map
2011-06-25 15:32:09 +02:00
NOTE: blitBackAll adds nearly everything to changed_blocks
2010-11-27 00:02:21 +01:00
*/
data->vmanip->blitBackAll(changed_blocks);
EMERGE_DBG_OUT("finishBlockMake: changed_blocks.size()="
<< changed_blocks->size());
/*
Copy transforming liquid information
*/
while (data->transforming_liquid.size()) {
m_transforming_liquid.push_back(data->transforming_liquid.front());
data->transforming_liquid.pop_front();
}
for (std::map<v3s16, MapBlock *>::iterator
it = changed_blocks->begin();
it != changed_blocks->end(); ++it) {
MapBlock *block = it->second;
if (!block)
continue;
/*
Update day/night difference cache of the MapBlocks
*/
block->expireDayNightDiff();
/*
Set block as modified
*/
block->raiseModified(MOD_STATE_WRITE_NEEDED,
MOD_REASON_EXPIRE_DAYNIGHTDIFF);
}
/*
Set central blocks as generated
*/
for (s16 x = bpmin.X; x <= bpmax.X; x++)
for (s16 z = bpmin.Z; z <= bpmax.Z; z++)
for (s16 y = bpmin.Y; y <= bpmax.Y; y++) {
MapBlock *block = getBlockNoCreateNoEx(v3s16(x, y, z));
if (!block)
continue;
block->setGenerated(true);
}
2012-12-22 06:34:35 +01:00
/*
Save changed parts of map
NOTE: Will be saved later.
*/
//save(MOD_STATE_WRITE_AT_UNLOAD);
}
2010-12-22 15:30:23 +01:00
ServerMapSector *ServerMap::createSector(v2s16 p2d)
{
DSTACKF("%s: p2d=(%d,%d)",
FUNCTION_NAME,
p2d.X, p2d.Y);
2012-12-22 06:34:35 +01:00
/*
Check if it exists already in memory
*/
ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
if(sector != NULL)
return sector;
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
/*
Try to load it from disk (with blocks)
*/
//if(loadSectorFull(p2d) == true)
/*
Try to load metadata from disk
2010-11-27 00:02:21 +01:00
*/
#if 0
if(loadSectorMeta(p2d) == true)
2010-11-27 00:02:21 +01:00
{
ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
if(sector == NULL)
2010-11-27 00:02:21 +01:00
{
infostream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
throw InvalidPositionException("");
2010-11-27 00:02:21 +01:00
}
return sector;
}
#endif
/*
Do not create over-limit
*/
2015-07-13 17:01:31 +02:00
const static u16 map_gen_limit = MYMIN(MAX_MAP_GENERATION_LIMIT,
g_settings->getU16("map_generation_limit"));
if(p2d.X < -map_gen_limit / MAP_BLOCKSIZE
|| p2d.X > map_gen_limit / MAP_BLOCKSIZE
|| p2d.Y < -map_gen_limit / MAP_BLOCKSIZE
|| p2d.Y > map_gen_limit / MAP_BLOCKSIZE)
throw InvalidPositionException("createSector(): pos. over limit");
/*
Generate blank sector
*/
2012-12-22 06:34:35 +01:00
2011-11-14 20:41:30 +01:00
sector = new ServerMapSector(this, p2d, m_gamedef);
2012-12-22 06:34:35 +01:00
// Sector position on map in nodes
2013-05-20 03:26:08 +02:00
//v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
2010-11-27 00:02:21 +01:00
/*
Insert to container
2010-11-27 00:02:21 +01:00
*/
2012-12-20 18:19:49 +01:00
m_sectors[p2d] = sector;
2012-12-22 06:34:35 +01:00
return sector;
}
#if 0
/*
This is a quick-hand function for calling makeBlock().
*/
MapBlock * ServerMap::generateBlock(
v3s16 p,
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> &modified_blocks
)
{
DSTACKF("%s: p=(%d,%d,%d)", FUNCTION_NAME, p.X, p.Y, p.Z);
2012-12-22 06:34:35 +01:00
/*infostream<<"generateBlock(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
2012-12-22 06:34:35 +01:00
2011-10-12 12:53:38 +02:00
bool enable_mapgen_debug_info = g_settings->getBool("enable_mapgen_debug_info");
2011-06-25 15:32:09 +02:00
TimeTaker timer("generateBlock");
2012-12-22 06:34:35 +01:00
//MapBlock *block = original_dummy;
2012-12-22 06:34:35 +01:00
v2s16 p2d(p.X, p.Z);
v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
2012-12-22 06:34:35 +01:00
/*
Do not generate over-limit
*/
if(blockpos_over_limit(p))
{
infostream<<FUNCTION_NAME<<": Block position over limit"<<std::endl;
throw InvalidPositionException("generateBlock(): pos. over limit");
}
/*
Create block make data
*/
BlockMakeData data;
initBlockMake(&data, p);
/*
Generate block
*/
{
TimeTaker t("mapgen::make_block()");
mapgen->makeChunk(&data);
//mapgen::make_block(&data);
if(enable_mapgen_debug_info == false)
t.stop(true); // Hide output
}
/*
Blit data back on map, update lighting, add mobs and whatever this does
*/
finishBlockMake(&data, modified_blocks);
/*
Get central block
*/
MapBlock *block = getBlockNoCreateNoEx(p);
#if 0
/*
Check result
*/
if(block)
{
bool erroneus_content = false;
for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
v3s16 p(x0,y0,z0);
MapNode n = block->getNode(p);
2011-07-23 15:55:26 +02:00
if(n.getContent() == CONTENT_IGNORE)
{
infostream<<"CONTENT_IGNORE at "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;
erroneus_content = true;
assert(0);
}
}
if(erroneus_content)
{
assert(0);
}
}
#endif
#if 0
/*
Generate a completely empty block
*/
if(block)
{
for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
MapNode n;
n.setContent(CONTENT_AIR);
block->setNode(v3s16(x0,y0,z0), n);
}
}
}
#endif
if(enable_mapgen_debug_info == false)
timer.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);
2012-12-22 06:34:35 +01:00
/*
Do not create over-limit
*/
2015-07-13 17:01:31 +02:00
if (blockpos_over_limit(p))
throw InvalidPositionException("createBlock(): pos. over limit");
2012-12-22 06:34:35 +01:00
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
/*
This will create or load a sector if not found in memory.
If block exists on disk, it will be loaded.
NOTE: On old save formats, this will be slow, as it generates
lighting on blocks for them.
*/
ServerMapSector *sector;
try {
sector = (ServerMapSector*)createSector(p2d);
assert(sector->getId() == MAPSECTOR_SERVER);
}
catch(InvalidPositionException &e)
{
infostream<<"createBlock: createSector() failed"<<std::endl;
throw e;
}
/*
NOTE: This should not be done, or at least the exception
should not be passed on as std::exception, because it
won't be catched at all.
*/
/*catch(std::exception &e)
{
infostream<<"createBlock: createSector() failed: "
<<e.what()<<std::endl;
throw e;
}*/
/*
Try to get a block from the sector
*/
MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
if(block)
{
if(block->isDummy())
block->unDummify();
return block;
}
// Create blank
block = sector->createBlankBlock(block_y);
return block;
}
MapBlock * ServerMap::emergeBlock(v3s16 p, bool create_blank)
{
DSTACKF("%s: p=(%d,%d,%d), create_blank=%d",
FUNCTION_NAME,
p.X, p.Y, p.Z, create_blank);
2012-12-22 06:34:35 +01:00
{
MapBlock *block = getBlockNoCreateNoEx(p);
if(block && block->isDummy() == false)
return block;
}
{
MapBlock *block = loadBlock(p);
if(block)
return block;
}
if (create_blank) {
ServerMapSector *sector = createSector(v2s16(p.X, p.Z));
MapBlock *block = sector->createBlankBlock(p.Y);
return block;
}
#if 0
if(allow_generate)
{
2012-12-20 18:19:49 +01:00
std::map<v3s16, MapBlock*> modified_blocks;
MapBlock *block = generateBlock(p, modified_blocks);
if(block)
{
MapEditEvent event;
event.type = MEET_OTHER;
event.p = p;
// Copy modified_blocks to event
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, MapBlock*>::iterator
i = modified_blocks.begin();
i != modified_blocks.end(); ++i)
{
2013-03-17 18:09:05 +01:00
event.modified_blocks.insert(i->first);
}
// Queue event
dispatchEvent(&event);
2012-12-22 06:34:35 +01:00
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) {
}
// N.B. This requires no synchronization, since data will not be modified unless
// the VoxelManipulator being updated belongs to the same thread.
void ServerMap::updateVManip(v3s16 pos)
{
Mapgen *mg = m_emerge->getCurrentMapgen();
if (!mg)
return;
MMVManip *vm = mg->vm;
if (!vm)
return;
if (!vm->m_area.contains(pos))
return;
s32 idx = vm->m_area.index(pos);
vm->m_data[idx] = getNodeNoEx(pos);
vm->m_flags[idx] &= ~VOXELFLAG_NO_DATA;
vm->m_is_dirty = true;
}
s16 ServerMap::findGroundLevel(v2s16 p2d)
2011-02-23 01:49:57 +01:00
{
#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;
2011-02-23 01:49:57 +01:00
}
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--)
2011-02-23 01:49:57 +01:00
{
MapNode n = getNodeNoEx(p);
if(content_walkable(n.d) && n.getContent() != CONTENT_IGNORE)
return p.Y;
}
2012-12-22 06:34:35 +01:00
// Move to plan b
plan_b:
#endif
/*
Determine from map generator noise functions
*/
s16 level = m_emerge->getGroundLevelAtPoint(p2d);
return level;
//double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT;
//return (s16)level;
2011-02-23 01:49:57 +01:00
}
bool ServerMap::loadFromFolders() {
2015-02-27 08:24:07 +01:00
if (!dbase->initialized() &&
!fs::PathExists(m_savedir + DIR_DELIM + "map.sqlite"))
return true;
return false;
}
void ServerMap::createDirs(std::string path)
2010-11-27 00:02:21 +01:00
{
if(fs::CreateAllDirs(path) == false)
2010-11-27 00:02:21 +01:00
{
m_dout<<"ServerMap: Failed to create directory "
2010-11-27 00:02:21 +01:00
<<"\""<<path<<"\""<<std::endl;
throw BaseException("ServerMap failed to create directory");
}
}
std::string ServerMap::getSectorDir(v2s16 pos, int layout)
2010-11-27 00:02:21 +01:00
{
char cc[9];
switch(layout)
{
case 1:
snprintf(cc, 9, "%.4x%.4x",
(unsigned int) pos.X & 0xffff,
(unsigned int) pos.Y & 0xffff);
2010-11-27 00:02:21 +01:00
return m_savedir + DIR_DELIM + "sectors" + DIR_DELIM + cc;
case 2:
snprintf(cc, 9, (std::string("%.3x") + DIR_DELIM + "%.3x").c_str(),
(unsigned int) pos.X & 0xfff,
(unsigned int) pos.Y & 0xfff);
2010-11-27 00:02:21 +01:00
return m_savedir + DIR_DELIM + "sectors2" + DIR_DELIM + cc;
default:
assert(false);
2014-04-15 19:49:32 +02:00
return "";
}
2010-11-27 00:02:21 +01:00
}
v2s16 ServerMap::getSectorPos(std::string dirname)
{
2014-04-15 19:49:32 +02:00
unsigned int x = 0, y = 0;
int r;
std::string component;
fs::RemoveLastPathComponent(dirname, &component, 1);
if(component.size() == 8)
{
// Old layout
r = sscanf(component.c_str(), "%4x%4x", &x, &y);
}
else if(component.size() == 3)
{
// New layout
fs::RemoveLastPathComponent(dirname, &component, 2);
r = sscanf(component.c_str(), (std::string("%3x") + DIR_DELIM + "%3x").c_str(), &x, &y);
// Sign-extend the 12 bit values up to 16 bits...
if(x & 0x800) x |= 0xF000;
if(y & 0x800) y |= 0xF000;
}
else
{
r = -1;
}
FATAL_ERROR_IF(r != 2, "getSectorPos()");
2010-11-27 00:02:21 +01:00
v2s16 pos((s16)x, (s16)y);
return pos;
}
v3s16 ServerMap::getBlockPos(std::string sectordir, std::string blockfile)
{
v2s16 p2d = getSectorPos(sectordir);
if(blockfile.size() != 4){
throw InvalidFilenameException("Invalid block filename");
}
unsigned int y;
int r = sscanf(blockfile.c_str(), "%4x", &y);
if(r != 1)
throw InvalidFilenameException("Invalid block filename");
return v3s16(p2d.X, y, p2d.Y);
}
std::string ServerMap::getBlockFilename(v3s16 p)
{
char cc[5];
snprintf(cc, 5, "%.4x", (unsigned int)p.Y&0xffff);
return cc;
}
void ServerMap::save(ModifiedState save_level)
2010-11-27 00:02:21 +01:00
{
DSTACK(FUNCTION_NAME);
if(m_map_saving_enabled == false) {
warningstream<<"Not saving map, saving disabled."<<std::endl;
2010-11-27 00:02:21 +01:00
return;
}
2012-12-22 06:34:35 +01:00
if(save_level == MOD_STATE_CLEAN)
infostream<<"ServerMap: Saving whole map, this can take time."
2010-11-27 00:02:21 +01:00
<<std::endl;
2012-12-22 06:34:35 +01:00
if (m_map_metadata_changed || save_level == MOD_STATE_CLEAN) {
if (settings_mgr.saveMapMeta())
m_map_metadata_changed = false;
}
2011-04-10 21:50:31 +02:00
// Profile modified reasons
Profiler modprofiler;
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
u32 sector_meta_count = 0;
u32 block_count = 0;
u32 block_count_all = 0; // Number of blocks in memory
2012-12-22 06:34:35 +01:00
// Don't do anything with sqlite unless something is really saved
bool save_started = false;
2012-12-20 18:19:49 +01:00
for(std::map<v2s16, MapSector*>::iterator i = m_sectors.begin();
i != m_sectors.end(); ++i) {
2012-12-20 18:19:49 +01:00
ServerMapSector *sector = (ServerMapSector*)i->second;
2010-11-27 00:02:21 +01:00
assert(sector->getId() == MAPSECTOR_SERVER);
2012-12-22 06:34:35 +01:00
if(sector->differs_from_disk || save_level == MOD_STATE_CLEAN) {
2011-02-05 13:55:16 +01:00
saveSectorMeta(sector);
sector_meta_count++;
2010-11-27 00:02:21 +01:00
}
MapBlockVect blocks;
2011-02-05 13:55:16 +01:00
sector->getBlocks(blocks);
2012-12-22 06:34:35 +01:00
for(MapBlockVect::iterator j = blocks.begin();
j != blocks.end(); ++j) {
2011-02-05 13:55:16 +01:00
MapBlock *block = *j;
2012-12-22 06:34:35 +01:00
block_count_all++;
if(block->getModified() >= (u32)save_level) {
// Lazy beginSave()
if(!save_started) {
beginSave();
save_started = true;
}
modprofiler.add(block->getModifiedReasonString(), 1);
2011-02-05 13:55:16 +01:00
saveBlock(block);
block_count++;
/*infostream<<"ServerMap: Written block ("
2011-02-05 13:55:16 +01:00
<<block->getPos().X<<","
<<block->getPos().Y<<","
<<block->getPos().Z<<")"
<<std::endl;*/
2010-11-27 00:02:21 +01:00
}
}
}
if(save_started)
endSave();
2010-11-27 00:02:21 +01:00
/*
Only print if something happened or saved whole map
*/
if(save_level == MOD_STATE_CLEAN || sector_meta_count != 0
|| block_count != 0) {
infostream<<"ServerMap: Written: "
2010-11-27 00:02:21 +01:00
<<sector_meta_count<<" sector metadata files, "
2010-12-21 01:25:47 +01:00
<<block_count<<" block files"
<<", "<<block_count_all<<" blocks in memory."
2010-11-27 00:02:21 +01:00
<<std::endl;
PrintInfo(infostream); // ServerMap/ClientMap:
infostream<<"Blocks modified by: "<<std::endl;
modprofiler.print(infostream);
2010-11-27 00:02:21 +01:00
}
}
void ServerMap::listAllLoadableBlocks(std::vector<v3s16> &dst)
2011-10-17 23:01:50 +02:00
{
2015-02-27 08:24:07 +01:00
if (loadFromFolders()) {
errorstream << "Map::listAllLoadableBlocks(): Result will be missing "
<< "all blocks that are stored in flat files." << std::endl;
2011-10-17 23:01:50 +02:00
}
dbase->listAllLoadableBlocks(dst);
2011-10-17 23:01:50 +02:00
}
void ServerMap::listAllLoadedBlocks(std::vector<v3s16> &dst)
{
for(std::map<v2s16, MapSector*>::iterator si = m_sectors.begin();
si != m_sectors.end(); ++si)
{
MapSector *sector = si->second;
MapBlockVect blocks;
sector->getBlocks(blocks);
for(MapBlockVect::iterator i = blocks.begin();
i != blocks.end(); ++i) {
v3s16 p = (*i)->getPos();
dst.push_back(p);
}
}
}
2010-11-27 00:02:21 +01:00
void ServerMap::saveSectorMeta(ServerMapSector *sector)
{
DSTACK(FUNCTION_NAME);
2010-11-27 00:02:21 +01:00
// Format used for writing
2013-08-01 22:51:36 +02:00
u8 version = SER_FMT_VER_HIGHEST_WRITE;
2010-11-27 00:02:21 +01:00
// Get destination
v2s16 pos = sector->getPos();
std::string dir = getSectorDir(pos);
createDirs(dir);
2012-12-22 06:34:35 +01:00
std::string fullpath = dir + DIR_DELIM + "meta";
std::ostringstream ss(std::ios_base::binary);
sector->serialize(ss, version);
2010-11-27 00:02:21 +01:00
if(!fs::safeWriteToFile(fullpath, ss.str()))
throw FileNotGoodException("Cannot write sector metafile");
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
sector->differs_from_disk = false;
}
MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load)
2010-11-27 00:02:21 +01:00
{
DSTACK(FUNCTION_NAME);
2010-11-27 00:02:21 +01:00
// Get destination
v2s16 p2d = getSectorPos(sectordir);
2011-04-10 23:19:40 +02:00
ServerMapSector *sector = NULL;
std::string fullpath = sectordir + DIR_DELIM + "meta";
2010-11-27 00:02:21 +01:00
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
2011-04-10 23:19:40 +02:00
{
// If the directory exists anyway, it probably is in some old
// format. Just go ahead and create the sector.
if(fs::PathExists(sectordir))
2011-04-10 23:19:40 +02:00
{
/*infostream<<"ServerMap::loadSectorMeta(): Sector metafile "
2011-04-10 23:19:40 +02:00
<<fullpath<<" doesn't exist but directory does."
<<" Continuing with a sector with no metadata."
<<std::endl;*/
2011-11-14 20:41:30 +01:00
sector = new ServerMapSector(this, p2d, m_gamedef);
2012-12-20 18:19:49 +01:00
m_sectors[p2d] = sector;
2011-04-10 23:19:40 +02:00
}
else
{
2011-04-10 23:19:40 +02:00
throw FileNotGoodException("Cannot open sector metafile");
}
2011-04-10 23:19:40 +02:00
}
else
{
sector = ServerMapSector::deSerialize
2011-11-14 20:41:30 +01:00
(is, this, p2d, m_sectors, m_gamedef);
if(save_after_load)
saveSectorMeta(sector);
2011-04-10 23:19:40 +02:00
}
2012-12-22 06:34:35 +01:00
2010-11-27 00:02:21 +01:00
sector->differs_from_disk = false;
return sector;
}
bool ServerMap::loadSectorMeta(v2s16 p2d)
2010-11-27 00:02:21 +01:00
{
DSTACK(FUNCTION_NAME);
2010-11-27 00:02:21 +01:00
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
// 2 - new sectors2/xxx/zzz/
// If we load from anything but the latest structure, we will
// immediately save to the new one, and remove the old.
int loadlayout = 1;
std::string sectordir1 = getSectorDir(p2d, 1);
std::string sectordir;
if(fs::PathExists(sectordir1))
{
sectordir = sectordir1;
}
else
{
loadlayout = 2;
sectordir = getSectorDir(p2d, 2);
}
try{
loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
return false;
}
catch(FileNotGoodException &e)
{
return false;
}
catch(std::exception &e)
{
return false;
}
2012-12-22 06:34:35 +01:00
return true;
}
#if 0
bool ServerMap::loadSectorFull(v2s16 p2d)
{
DSTACK(FUNCTION_NAME);
MapSector *sector = NULL;
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
// 2 - new sectors2/xxx/zzz/
// If we load from anything but the latest structure, we will
// immediately save to the new one, and remove the old.
int loadlayout = 1;
std::string sectordir1 = getSectorDir(p2d, 1);
std::string sectordir;
if(fs::PathExists(sectordir1))
{
sectordir = sectordir1;
}
else
{
loadlayout = 2;
sectordir = getSectorDir(p2d, 2);
}
2010-11-27 00:02:21 +01:00
try{
sector = loadSectorMeta(sectordir, loadlayout != 2);
2010-11-27 00:02:21 +01:00
}
catch(InvalidFilenameException &e)
{
return false;
}
catch(FileNotGoodException &e)
{
return false;
}
catch(std::exception &e)
{
return false;
}
2012-12-22 06:34:35 +01:00
2011-02-11 19:37:54 +01:00
/*
Load blocks
*/
2011-02-05 13:55:16 +01:00
std::vector<fs::DirListNode> list2 = fs::GetDirListing
(sectordir);
2011-02-05 13:55:16 +01:00
std::vector<fs::DirListNode>::iterator i2;
for(i2=list2.begin(); i2!=list2.end(); i2++)
2010-11-27 00:02:21 +01:00
{
2011-02-05 13:55:16 +01:00
// We want files
if(i2->dir)
continue;
try{
loadBlock(sectordir, i2->name, sector, loadlayout != 2);
2011-02-05 13:55:16 +01:00
}
catch(InvalidFilenameException &e)
2010-11-27 00:02:21 +01:00
{
2011-02-05 13:55:16 +01:00
// This catches unknown crap in directory
2010-11-27 00:02:21 +01:00
}
}
if(loadlayout != 2)
{
infostream<<"Sector converted to new layout - deleting "<<
sectordir1<<std::endl;
fs::RecursiveDelete(sectordir1);
}
2010-11-27 00:02:21 +01:00
return true;
}
#endif
Database *ServerMap::createDatabase(
const std::string &name,
const std::string &savedir,
Settings &conf)
2015-02-27 08:24:07 +01:00
{
if (name == "sqlite3")
return new Database_SQLite3(savedir);
if (name == "dummy")
return new Database_Dummy();
#if USE_LEVELDB
else if (name == "leveldb")
return new Database_LevelDB(savedir);
#endif
#if USE_REDIS
else if (name == "redis")
return new Database_Redis(conf);
#endif
2016-05-14 11:00:42 +02:00
#if USE_POSTGRESQL
else if (name == "postgresql")
return new Database_PostgreSQL(conf);
#endif
2015-02-27 08:24:07 +01:00
else
throw BaseException(std::string("Database backend ") + name + " not supported.");
}
void ServerMap::beginSave()
{
dbase->beginSave();
}
void ServerMap::endSave()
{
dbase->endSave();
}
bool ServerMap::saveBlock(MapBlock *block)
2010-11-27 00:02:21 +01:00
{
return saveBlock(block, dbase);
}
bool ServerMap::saveBlock(MapBlock *block, Database *db)
{
v3s16 p3d = block->getPos();
// Dummy blocks are not written
if (block->isDummy()) {
warningstream << "saveBlock: Not writing dummy block "
<< PP(p3d) << std::endl;
return true;
}
// Format used for writing
u8 version = SER_FMT_VER_HIGHEST_WRITE;
/*
[0] u8 serialization version
[1] data
*/
std::ostringstream o(std::ios_base::binary);
o.write((char*) &version, 1);
block->serialize(o, version, true);
std::string data = o.str();
bool ret = db->saveBlock(p3d, data);
if (ret) {
// We just wrote it to the disk so clear modified flag
block->resetModified();
}
return ret;
2010-11-27 00:02:21 +01:00
}
void ServerMap::loadBlock(std::string sectordir, std::string blockfile,
MapSector *sector, bool save_after_load)
2010-11-27 00:02:21 +01:00
{
DSTACK(FUNCTION_NAME);
2010-11-29 16:55:07 +01:00
std::string fullpath = sectordir + DIR_DELIM + blockfile;
try {
2010-11-29 16:55:07 +01:00
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
throw FileNotGoodException("Cannot open block file");
2012-12-22 06:34:35 +01:00
v3s16 p3d = getBlockPos(sectordir, blockfile);
v2s16 p2d(p3d.X, p3d.Z);
2012-12-22 06:34:35 +01:00
assert(sector->getPos() == p2d);
2012-12-22 06:34:35 +01:00
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
2010-11-27 00:02:21 +01:00
if(is.fail())
throw SerializationError("ServerMap::loadBlock(): Failed"
" to read MapBlock version");
2010-11-27 00:02:21 +01:00
/*u32 block_size = MapBlock::serializedLength(version);
SharedBuffer<u8> data(block_size);
is.read((char*)*data, block_size);*/
2010-11-27 00:02:21 +01:00
// This will always return a sector because we're the server
//MapSector *sector = emergeSector(p2d);
2010-11-27 00:02:21 +01:00
MapBlock *block = NULL;
bool created_new = false;
2011-06-25 23:03:58 +02:00
block = sector->getBlockNoCreateNoEx(p3d.Y);
if(block == NULL)
{
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
2012-12-22 06:34:35 +01:00
// Read basic data
block->deSerialize(is, version, true);
2010-11-27 00:02:21 +01:00
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
2012-12-22 06:34:35 +01:00
/*
Save blocks loaded in old format in new format
*/
2013-08-01 22:51:36 +02:00
if(version < SER_FMT_VER_HIGHEST_WRITE || save_after_load)
{
saveBlock(block);
2012-12-22 06:34:35 +01:00
// Should be in database now, so delete the old file
fs::RecursiveDelete(fullpath);
}
2012-12-22 06:34:35 +01:00
// We just loaded it from the disk, so it's up-to-date.
block->resetModified();
2010-11-29 16:55:07 +01:00
}
catch(SerializationError &e)
{
warningstream<<"Invalid block data on disk "
<<"fullpath="<<fullpath
<<" (SerializationError). "
<<"what()="<<e.what()
2010-11-29 16:55:07 +01:00
<<std::endl;
2013-07-27 20:34:30 +02:00
// Ignoring. A new one will be generated.
abort();
// TODO: Backup file; name is in fullpath.
2010-11-29 16:55:07 +01:00
}
2010-11-27 00:02:21 +01:00
}
void ServerMap::loadBlock(std::string *blob, v3s16 p3d, MapSector *sector, bool save_after_load)
{
DSTACK(FUNCTION_NAME);
try {
std::istringstream is(*blob, std::ios_base::binary);
2012-12-22 06:34:35 +01:00
u8 version = SER_FMT_VER_INVALID;
is.read((char*)&version, 1);
if(is.fail())
throw SerializationError("ServerMap::loadBlock(): Failed"
" to read MapBlock version");
/*u32 block_size = MapBlock::serializedLength(version);
SharedBuffer<u8> data(block_size);
is.read((char*)*data, block_size);*/
// This will always return a sector because we're the server
//MapSector *sector = emergeSector(p2d);
MapBlock *block = NULL;
bool created_new = false;
block = sector->getBlockNoCreateNoEx(p3d.Y);
if(block == NULL)
{
block = sector->createBlankBlockNoInsert(p3d.Y);
created_new = true;
}
2012-12-22 06:34:35 +01:00
// Read basic data
block->deSerialize(is, version, true);
2012-12-22 06:34:35 +01:00
// If it's a new block, insert it to the map
if(created_new)
sector->insertBlock(block);
2012-12-22 06:34:35 +01:00
/*
Save blocks loaded in old format in new format
*/
2013-08-01 22:51:36 +02:00
//if(version < SER_FMT_VER_HIGHEST_READ || save_after_load)
2011-11-16 12:03:28 +01:00
// Only save if asked to; no need to update version
if(save_after_load)
saveBlock(block);
2012-12-22 06:34:35 +01:00
// We just loaded it from, so it's up-to-date.
block->resetModified();
}
catch(SerializationError &e)
{
errorstream<<"Invalid block data in database"
<<" ("<<p3d.X<<","<<p3d.Y<<","<<p3d.Z<<")"
<<" (SerializationError): "<<e.what()<<std::endl;
2012-12-22 06:34:35 +01:00
// 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");
}
}
}
MapBlock* ServerMap::loadBlock(v3s16 blockpos)
{
DSTACK(FUNCTION_NAME);
v2s16 p2d(blockpos.X, blockpos.Z);
std::string ret;
dbase->loadBlock(blockpos, &ret);
if (ret != "") {
loadBlock(&ret, blockpos, createSector(p2d), false);
return getBlockNoCreateNoEx(blockpos);
}
// Not found in database, try the files
// The directory layout we're going to load from.
// 1 - original sectors/xxxxzzzz/
// 2 - new sectors2/xxx/zzz/
// If we load from anything but the latest structure, we will
// immediately save to the new one, and remove the old.
int loadlayout = 1;
std::string sectordir1 = getSectorDir(p2d, 1);
std::string sectordir;
if(fs::PathExists(sectordir1))
{
sectordir = sectordir1;
}
else
{
loadlayout = 2;
sectordir = getSectorDir(p2d, 2);
}
2012-12-22 06:34:35 +01:00
/*
Make sure sector is loaded
*/
MapSector *sector = getSectorNoGenerateNoEx(p2d);
if(sector == NULL)
{
try{
sector = loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
return NULL;
}
catch(FileNotGoodException &e)
{
return NULL;
}
catch(std::exception &e)
{
return NULL;
}
}
2012-12-22 06:34:35 +01:00
/*
Make sure file exists
*/
std::string blockfilename = getBlockFilename(blockpos);
if(fs::PathExists(sectordir + DIR_DELIM + blockfilename) == false)
return NULL;
/*
Load block and save it to the database
*/
loadBlock(sectordir, blockfilename, sector, true);
return getBlockNoCreateNoEx(blockpos);
}
bool ServerMap::deleteBlock(v3s16 blockpos)
{
if (!dbase->deleteBlock(blockpos))
return false;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if (block) {
v2s16 p2d(blockpos.X, blockpos.Z);
MapSector *sector = getSectorNoGenerateNoEx(p2d);
if (!sector)
return false;
sector->deleteBlock(block);
}
return true;
}
2010-11-27 00:02:21 +01:00
void ServerMap::PrintInfo(std::ostream &out)
{
out<<"ServerMap: ";
}
MMVManip::MMVManip(Map *map):
VoxelManipulator(),
m_is_dirty(false),
m_create_area(false),
m_map(map)
2011-01-24 15:36:58 +01:00
{
}
MMVManip::~MMVManip()
2011-01-24 15:36:58 +01:00
{
}
void MMVManip::initialEmerge(v3s16 blockpos_min, v3s16 blockpos_max,
bool load_if_inexistent)
2011-01-24 15:36:58 +01:00
{
TimeTaker timer1("initialEmerge", &emerge_time);
2011-01-24 15:36:58 +01:00
// Units of these are MapBlocks
v3s16 p_min = blockpos_min;
v3s16 p_max = blockpos_max;
VoxelArea block_area_nodes
(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
2012-12-22 06:34:35 +01:00
u32 size_MB = block_area_nodes.getVolume()*4/1000000;
if(size_MB >= 1)
{
infostream<<"initialEmerge: area: ";
block_area_nodes.print(infostream);
infostream<<" ("<<size_MB<<"MB)";
infostream<<std::endl;
}
2011-01-24 15:36:58 +01:00
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++)
{
2013-02-17 07:47:49 +01:00
u8 flags = 0;
MapBlock *block;
2011-01-24 15:36:58 +01:00
v3s16 p(x,y,z);
2012-12-20 18:19:49 +01:00
std::map<v3s16, u8>::iterator n;
2011-01-24 15:36:58 +01:00
n = m_loaded_blocks.find(p);
2012-12-20 18:19:49 +01:00
if(n != m_loaded_blocks.end())
2011-01-24 15:36:58 +01:00
continue;
2012-12-22 06:34:35 +01:00
2011-01-24 15:36:58 +01:00
bool block_data_inexistent = false;
try
{
TimeTaker timer1("emerge load", &emerge_load_time);
2013-02-17 07:47:49 +01:00
block = m_map->getBlockNoCreate(p);
2011-01-24 15:36:58 +01:00
if(block->isDummy())
block_data_inexistent = true;
else
block->copyTo(*this);
}
catch(InvalidPositionException &e)
{
block_data_inexistent = true;
}
if(block_data_inexistent)
{
if (load_if_inexistent) {
ServerMap *svrmap = (ServerMap *)m_map;
block = svrmap->emergeBlock(p, false);
if (block == NULL)
block = svrmap->createBlock(p);
2015-01-14 06:43:33 +01:00
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);
}
2011-01-24 15:36:58 +01:00
}
}
2013-02-22 04:26:21 +01:00
/*else if (block->getNode(0, 0, 0).getContent() == CONTENT_IGNORE)
2013-02-17 07:47:49 +01:00
{
// Mark that block was loaded as blank
flags |= VMANIP_BLOCK_CONTAINS_CIGNORE;
2013-02-22 04:26:21 +01:00
}*/
2011-01-24 15:36:58 +01:00
2012-12-20 18:19:49 +01:00
m_loaded_blocks[p] = flags;
}
m_is_dirty = false;
}
void MMVManip::blitBackAll(std::map<v3s16, MapBlock*> *modified_blocks,
bool overwrite_generated)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
2012-12-22 06:34:35 +01:00
/*
Copy data of all blocks
*/
2012-12-20 18:19:49 +01:00
for(std::map<v3s16, u8>::iterator
i = m_loaded_blocks.begin();
i != m_loaded_blocks.end(); ++i)
{
2012-12-20 18:19:49 +01:00
v3s16 p = i->first;
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
2012-12-20 18:19:49 +01:00
bool existed = !(i->second & VMANIP_BLOCK_DATA_INEXIST);
if ((existed == false) || (block == NULL) ||
(overwrite_generated == false && block->isGenerated() == true))
continue;
2013-02-22 04:26:21 +01:00
block->copyFrom(*this);
2012-12-20 18:19:49 +01:00
2013-02-22 04:26:21 +01:00
if(modified_blocks)
2012-12-20 18:19:49 +01:00
(*modified_blocks)[p] = block;
2011-01-24 15:36:58 +01:00
}
}
//END