minetest/src/map.cpp

4405 lines
100 KiB
C++
Raw Normal View History

2010-11-27 00:02:21 +01:00
/*
Minetest-c55
2011-04-30 01:12:32 +02:00
Copyright (C) 2010-2011 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
(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.
You should have received a copy of the GNU 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 "main.h"
#include "client.h"
#include "filesys.h"
#include "utility.h"
#include "voxel.h"
2010-12-22 02:33:58 +01:00
#include "porting.h"
#include "mapgen.h"
2011-06-26 01:34:36 +02:00
#include "nodemetadata.h"
2010-11-27 00:02:21 +01:00
/*
SQLite format specification:
- Initially only replaces sectors/ and sectors2/
If map.sqlite does not exist in the save dir
or the block was not found in the database
the map will try to load from sectors folder.
In either case, map.sqlite will be created
and all future saves will save there.
Structure of map.sqlite:
Tables:
blocks
(PK) INT pos
BLOB data
*/
/*
Map
*/
2010-11-27 00:02:21 +01:00
Map::Map(std::ostream &dout):
m_dout(dout),
2011-02-05 13:55:16 +01:00
m_sector_cache(NULL)
2010-11-27 00:02:21 +01:00
{
/*m_sector_mutex.Init();
assert(m_sector_mutex.IsInitialized());*/
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
*/
core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
for(; i.atEnd() == false; i++)
{
MapSector *sector = i.getNode()->getValue();
delete sector;
}
}
2011-02-23 01:49:57 +01:00
void Map::addEventReceiver(MapEventReceiver *event_receiver)
{
m_event_receivers.insert(event_receiver, false);
}
void Map::removeEventReceiver(MapEventReceiver *event_receiver)
{
if(m_event_receivers.find(event_receiver) == NULL)
return;
m_event_receivers.remove(event_receiver);
}
void Map::dispatchEvent(MapEditEvent *event)
{
for(core::map<MapEventReceiver*, bool>::Iterator
i = m_event_receivers.getIterator();
i.atEnd()==false; i++)
{
MapEventReceiver* event_receiver = i.getNode()->getKey();
event_receiver->onMapEditEvent(event);
}
}
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;
}
core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
2010-11-27 00:02:21 +01:00
if(n == NULL)
return NULL;
2010-11-27 00:02:21 +01:00
MapSector *sector = n->getValue();
// 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();
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)
{
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 = getBlockNoCreate(blockpos);
return (block != NULL);
}
// Returns a CONTENT_IGNORE node if not found
MapNode Map::getNodeNoEx(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
return MapNode(CONTENT_IGNORE);
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
return block->getNodeNoCheck(relpos);
}
// throws InvalidPositionException if not found
MapNode Map::getNode(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
throw InvalidPositionException();
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
return block->getNodeNoCheck(relpos);
}
// 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;
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,
core::map<v3s16, u8> & from_nodes,
2010-11-27 00:02:21 +01:00
core::map<v3s16, bool> & light_sources,
core::map<v3s16, MapBlock*> & modified_blocks)
{
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.size() == 0)
return;
u32 blockchangecount = 0;
core::map<v3s16, u8> unlighted_nodes;
core::map<v3s16, u8>::Iterator j;
j = from_nodes.getIterator();
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
// Cache this a bit, too
bool block_checked_in_modified = false;
for(; j.atEnd() == false; j++)
{
v3s16 pos = j.getNode()->getKey();
v3s16 blockpos = getNodeBlockPos(pos);
// 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
v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
// Get node straight from the block
MapNode n = block->getNode(relpos);
2010-11-27 00:02:21 +01:00
u8 oldlight = j.getNode()->getValue();
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 = getNodeBlockPos(n2pos);
try
{
// 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;
}
2010-11-27 00:02:21 +01:00
// Calculate relative position in block
v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
// Get node straight from the block
MapNode n2 = block->getNode(relpos);
2010-11-27 00:02:21 +01:00
bool changed = false;
//TODO: Optimize output by optimizing light_sources?
/*
If the neighbor is dimmer than what was specified
as oldlight (the light of the previous node)
*/
2010-12-18 16:46:00 +01:00
if(n2.getLight(bank) < oldlight)
2010-11-27 00:02:21 +01:00
{
/*
And the neighbor is transparent and it has some light
*/
2010-12-18 16:46:00 +01:00
if(n2.light_propagates() && n2.getLight(bank) != 0)
2010-11-27 00:02:21 +01:00
{
/*
Set light to 0 and add to queue
*/
2010-12-18 16:46:00 +01:00
u8 current_light = n2.getLight(bank);
n2.setLight(bank, 0);
2010-11-27 00:02:21 +01:00
block->setNode(relpos, n2);
unlighted_nodes.insert(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))
{
std::cout<<"Removed from light_sources"<<std::endl;
light_sources.remove(n2pos);
}*/
}
2010-12-13 02:19:12 +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, true);
}
// 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)
{
modified_blocks.insert(blockpos, block);
}
block_checked_in_modified = true;
}
}
catch(InvalidPositionException &e)
{
continue;
}
}
}
/*dstream<<"unspreadLight(): Changed block "
<<blockchangecount<<" times"
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
2010-11-27 00:02:21 +01:00
if(unlighted_nodes.size() > 0)
2010-12-18 16:46:00 +01:00
unspreadLight(bank, unlighted_nodes, light_sources, modified_blocks);
2010-11-27 00:02:21 +01:00
}
/*
A single-node wrapper of the above
*/
2010-12-18 16:46:00 +01:00
void Map::unLightNeighbors(enum LightBank bank,
v3s16 pos, u8 lightwas,
2010-11-27 00:02:21 +01:00
core::map<v3s16, bool> & light_sources,
core::map<v3s16, MapBlock*> & modified_blocks)
{
core::map<v3s16, u8> from_nodes;
from_nodes.insert(pos, lightwas);
2010-12-18 16:46:00 +01:00
unspreadLight(bank, from_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,
core::map<v3s16, bool> & from_nodes,
2010-11-27 00:02:21 +01:00
core::map<v3s16, MapBlock*> & modified_blocks)
{
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.size() == 0)
return;
2010-11-27 00:02:21 +01:00
u32 blockchangecount = 0;
core::map<v3s16, bool> lighted_nodes;
core::map<v3s16, bool>::Iterator j;
j = from_nodes.getIterator();
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
// Cache this a bit, too
bool block_checked_in_modified = false;
2010-11-27 00:02:21 +01:00
for(; j.atEnd() == false; j++)
//for(; j != from_nodes.end(); j++)
{
v3s16 pos = j.getNode()->getKey();
//v3s16 pos = *j;
//dstream<<"pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"<<std::endl;
v3s16 blockpos = getNodeBlockPos(pos);
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
v3s16 relpos = pos - blockpos_last * MAP_BLOCKSIZE;
// Get node straight from the block
MapNode n = block->getNode(relpos);
2010-12-18 16:46:00 +01:00
u8 oldlight = n.getLight(bank);
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 = getNodeBlockPos(n2pos);
try
{
// 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;
}
2010-11-27 00:02:21 +01:00
// Calculate relative position in block
v3s16 relpos = n2pos - blockpos * MAP_BLOCKSIZE;
// Get node straight from the block
MapNode n2 = block->getNode(relpos);
2010-11-27 00:02:21 +01:00
bool changed = false;
/*
If the neighbor is brighter than the current node,
add to list (it will light up this node on its turn)
*/
2010-12-18 16:46:00 +01:00
if(n2.getLight(bank) > undiminish_light(oldlight))
2010-11-27 00:02:21 +01:00
{
lighted_nodes.insert(n2pos, true);
//lighted_nodes.push_back(n2pos);
changed = true;
}
/*
If the neighbor is dimmer than how much light this node
would spread on it, add to list
*/
2010-12-18 16:46:00 +01:00
if(n2.getLight(bank) < newlight)
2010-11-27 00:02:21 +01:00
{
if(n2.light_propagates())
{
2010-12-18 16:46:00 +01:00
n2.setLight(bank, newlight);
2010-11-27 00:02:21 +01:00
block->setNode(relpos, n2);
lighted_nodes.insert(n2pos, true);
//lighted_nodes.push_back(n2pos);
changed = true;
}
}
// 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)
{
modified_blocks.insert(blockpos, block);
}
block_checked_in_modified = true;
}
}
catch(InvalidPositionException &e)
{
continue;
}
}
}
/*dstream<<"spreadLight(): Changed block "
<<blockchangecount<<" times"
<<" for "<<from_nodes.size()<<" nodes"
<<std::endl;*/
2010-11-27 00:02:21 +01:00
if(lighted_nodes.size() > 0)
2010-12-18 16:46:00 +01:00
spreadLight(bank, lighted_nodes, modified_blocks);
2010-11-27 00:02:21 +01:00
}
/*
A single-node source variation of the above.
*/
2010-12-18 16:46:00 +01:00
void Map::lightNeighbors(enum LightBank bank,
v3s16 pos,
2010-11-27 00:02:21 +01:00
core::map<v3s16, MapBlock*> & modified_blocks)
{
core::map<v3s16, bool> from_nodes;
from_nodes.insert(pos, true);
2010-12-18 16:46:00 +01:00
spreadLight(bank, from_nodes, modified_blocks);
2010-11-27 00:02:21 +01:00
}
2010-12-18 16:46:00 +01:00
v3s16 Map::getBrightestNeighbour(enum LightBank bank, v3s16 p)
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
};
2010-11-27 00:02:21 +01:00
u8 brightest_light = 0;
v3s16 brightest_pos(0,0,0);
bool found_something = false;
// Loop through 6 neighbors
for(u16 i=0; i<6; i++){
// Get the position of the neighbor node
v3s16 n2pos = p + dirs[i];
MapNode n2;
try{
n2 = getNode(n2pos);
}
catch(InvalidPositionException &e)
{
continue;
}
2010-12-18 16:46:00 +01:00
if(n2.getLight(bank) > brightest_light || found_something == false){
brightest_light = n2.getLight(bank);
2010-11-27 00:02:21 +01:00
brightest_pos = n2pos;
found_something = true;
}
}
if(found_something == false)
throw InvalidPositionException();
2010-11-27 00:02:21 +01:00
return brightest_pos;
}
/*
Propagates sunlight down from a node.
Starting point gets sunlight.
Returns the lowest y value of where the sunlight went.
Mud is turned into grass in where the sunlight stops.
2010-11-27 00:02:21 +01:00
*/
s16 Map::propagateSunlight(v3s16 start,
core::map<v3s16, MapBlock*> & modified_blocks)
{
s16 y = start.Y;
for(; ; y--)
{
v3s16 pos(start.X, y, start.Z);
2010-11-27 00:02:21 +01:00
v3s16 blockpos = getNodeBlockPos(pos);
MapBlock *block;
try{
block = getBlockNoCreate(blockpos);
}
catch(InvalidPositionException &e)
{
break;
}
v3s16 relpos = pos - blockpos*MAP_BLOCKSIZE;
MapNode n = block->getNode(relpos);
if(n.sunlight_propagates())
{
2010-12-18 16:46:00 +01:00
n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
2010-11-27 00:02:21 +01:00
block->setNode(relpos, n);
modified_blocks.insert(blockpos, block);
}
else
{
/*// Turn mud into grass
2011-07-23 15:55:26 +02:00
if(n.getContent() == CONTENT_MUD)
{
2011-07-23 15:55:26 +02:00
n.setContent(CONTENT_GRASS);
block->setNode(relpos, n);
modified_blocks.insert(blockpos, block);
}*/
// Sunlight goes no further
2010-11-27 00:02:21 +01:00
break;
}
}
return y + 1;
}
2010-12-18 16:46:00 +01:00
void Map::updateLighting(enum LightBank bank,
core::map<v3s16, MapBlock*> & a_blocks,
2010-11-27 00:02:21 +01:00
core::map<v3s16, MapBlock*> & modified_blocks)
{
/*m_dout<<DTIME<<"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();
core::map<v3s16, MapBlock*> blocks_to_update;
2010-11-27 00:02:21 +01:00
core::map<v3s16, bool> light_sources;
2010-11-27 00:02:21 +01:00
core::map<v3s16, u8> unlight_from;
2010-11-27 00:02:21 +01:00
core::map<v3s16, MapBlock*>::Iterator i;
i = a_blocks.getIterator();
for(; i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
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();
modified_blocks.insert(pos, block);
blocks_to_update.insert(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++)
{
2010-11-27 00:02:21 +01:00
try{
v3s16 p(x,y,z);
MapNode n = block->getNode(v3s16(x,y,z));
2010-12-18 16:46:00 +01:00
u8 oldlight = n.getLight(bank);
n.setLight(bank, 0);
2010-11-27 00:02:21 +01:00
block->setNode(v3s16(x,y,z), n);
2010-11-27 00:02:21 +01:00
// Collect borders for unlighting
if(x==0 || x == MAP_BLOCKSIZE-1
2010-12-13 02:19:12 +01:00
|| y==0 || y == MAP_BLOCKSIZE-1
|| z==0 || z == MAP_BLOCKSIZE-1)
2010-11-27 00:02:21 +01:00
{
v3s16 p_map = p + v3s16(
MAP_BLOCKSIZE*pos.X,
MAP_BLOCKSIZE*pos.Y,
MAP_BLOCKSIZE*pos.Z);
unlight_from.insert(p_map, oldlight);
}
}
catch(InvalidPositionException &e)
{
/*
This would happen when dealing with a
dummy block.
*/
//assert(0);
dstream<<"updateLighting(): InvalidPositionException"
<<std::endl;
}
}
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
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
{
// Invalid lighting bank
2010-12-18 16:46:00 +01:00
assert(0);
}
2010-11-27 00:02:21 +01:00
/*dstream<<"Bottom for sunlight-propagated block ("
<<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)
{
assert(0);
}
2010-11-27 00:02:21 +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
//if(g_settings.get(""))
{
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
#if 0
2010-11-27 00:02:21 +01:00
{
2011-01-24 15:36:58 +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
}
2010-11-27 00:02:21 +01:00
if(debug)
{
u32 diff = modified_blocks.size() - count_was;
count_was = modified_blocks.size();
dstream<<"unspreadLight modified "<<diff<<std::endl;
}
{
2011-01-24 15:36:58 +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
}
2010-11-27 00:02:21 +01:00
if(debug)
{
u32 diff = modified_blocks.size() - count_was;
count_was = modified_blocks.size();
dstream<<"spreadLight modified "<<diff<<std::endl;
}
2011-01-24 15:36:58 +01:00
#endif
2011-01-24 15:36:58 +01:00
{
//MapVoxelManipulator vmanip(this);
// Make a manual voxel manipulator and load all the blocks
// that touch the requested blocks
ManualMapVoxelManipulator vmanip(this);
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 p(x,y,z);
MapBlock *block = getBlockNoCreateNoEx(p);
if(block == NULL)
continue;
if(block->isDummy())
continue;
if(block->getLightingExpired())
continue;
vmanip.initialEmerge(p, p);
}*/
// Lighting of block will be updated completely
block->setLightingExpired(false);
2011-01-24 15:36:58 +01:00
}
2011-01-24 15:36:58 +01:00
{
//TimeTaker timer("unSpreadLight");
vmanip.unspreadLight(bank, unlight_from, light_sources);
}
{
//TimeTaker timer("spreadLight");
vmanip.spreadLight(bank, light_sources);
}
{
//TimeTaker timer("blitBack");
vmanip.blitBack(modified_blocks);
}
/*dstream<<"emerge_time="<<emerge_time<<std::endl;
emerge_time = 0;*/
}
2010-11-27 00:02:21 +01:00
//m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
}
2010-12-18 16:46:00 +01:00
void Map::updateLighting(core::map<v3s16, MapBlock*> & a_blocks,
core::map<v3s16, MapBlock*> & modified_blocks)
{
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
*/
for(core::map<v3s16, MapBlock*>::Iterator
i = modified_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
block->updateDayNightDiff();
}
2010-12-18 16:46:00 +01:00
}
2010-11-27 00:02:21 +01:00
/*
*/
void Map::addNodeAndUpdate(v3s16 p, MapNode n,
core::map<v3s16, MapBlock*> &modified_blocks)
{
/*PrintInfo(m_dout);
m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
2010-11-27 00:02:21 +01:00
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
2010-11-27 00:02:21 +01:00
/*
From this node to nodes underneath:
If lighting is sunlight (1.0), unlight neighbours and
set lighting to 0.
Else discontinue.
*/
v3s16 toppos = p + v3s16(0,1,0);
2010-12-21 17:08:24 +01:00
v3s16 bottompos = p + v3s16(0,-1,0);
2010-11-27 00:02:21 +01:00
2010-12-18 16:46:00 +01:00
bool node_under_sunlight = true;
core::map<v3s16, bool> light_sources;
2010-11-27 00:02:21 +01:00
/*
If there is a node at top and it doesn't have sunlight,
there has not been any sunlight going down.
Otherwise there probably is.
*/
try{
MapNode topnode = getNode(toppos);
2010-12-18 16:46:00 +01:00
if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
2010-11-27 00:02:21 +01:00
node_under_sunlight = false;
}
catch(InvalidPositionException &e)
{
}
#if 0
/*
If the new node is solid and there is grass below, change it to mud
*/
2011-07-23 15:55:26 +02:00
if(content_features(n).walkable == true)
2010-12-21 17:08:24 +01:00
{
try{
MapNode bottomnode = getNode(bottompos);
2011-07-23 15:55:26 +02:00
if(bottomnode.getContent() == CONTENT_GRASS
|| bottomnode.getContent() == CONTENT_GRASS_FOOTSTEPS)
2010-12-21 17:08:24 +01:00
{
2011-07-23 15:55:26 +02:00
bottomnode.setContent(CONTENT_MUD);
2010-12-21 17:08:24 +01:00
setNode(bottompos, bottomnode);
}
}
catch(InvalidPositionException &e)
{
}
}
#endif
2010-11-27 00:02:21 +01:00
#if 0
/*
If the new node is mud and it is under sunlight, change it
to grass
*/
2011-07-23 15:55:26 +02:00
if(n.getContent() == CONTENT_MUD && node_under_sunlight)
{
2011-07-23 15:55:26 +02:00
n.setContent(CONTENT_GRASS);
}
#endif
/*
Remove all light that has come out of this node
*/
2010-12-18 16:46:00 +01:00
enum LightBank banks[] =
{
LIGHTBANK_DAY,
LIGHTBANK_NIGHT
};
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
u8 lightwas = getNode(p).getLight(bank);
// 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);
2011-02-23 01:49:57 +01:00
assert(isValidPosition(p));
2010-12-18 16:46:00 +01:00
// Unlight neighbours of node.
// This means setting light of all consequent dimmer nodes
// to 0.
// This also collects the nodes at the border which will spread
// light again into this.
unLightNeighbors(bank, p, lightwas, light_sources, modified_blocks);
n.setLight(bank, 0);
}
/*
If node lets sunlight through and is under sunlight, it has
sunlight too.
*/
2011-07-23 15:55:26 +02:00
if(node_under_sunlight && content_features(n).sunlight_propagates)
{
n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
}
/*
Set the node on the map
*/
2010-11-27 00:02:21 +01:00
setNode(p, n);
2011-04-04 02:45:08 +02:00
/*
Add intial metadata
*/
2011-07-23 15:55:26 +02:00
NodeMetadata *meta_proto = content_features(n).initial_metadata;
2011-04-04 02:45:08 +02:00
if(meta_proto)
{
NodeMetadata *meta = meta_proto->clone();
setNodeMetadata(p, meta);
}
2010-11-27 00:02:21 +01:00
/*
If node is under sunlight and doesn't let sunlight through,
take all sunlighted nodes under it and clear light from them
and from where the light has been spread.
2010-12-18 16:46:00 +01:00
TODO: This could be optimized by mass-unlighting instead
of looping
2010-11-27 00:02:21 +01:00
*/
2011-07-23 15:55:26 +02:00
if(node_under_sunlight && !content_features(n).sunlight_propagates)
2010-11-27 00:02:21 +01:00
{
s16 y = p.Y - 1;
for(;; y--){
//m_dout<<DTIME<<"y="<<y<<std::endl;
v3s16 n2pos(p.X, y, p.Z);
2010-11-27 00:02:21 +01:00
MapNode n2;
try{
n2 = getNode(n2pos);
}
catch(InvalidPositionException &e)
{
break;
}
2010-12-18 16:46:00 +01:00
if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
2010-11-27 00:02:21 +01:00
{
2010-12-18 16:46:00 +01:00
unLightNeighbors(LIGHTBANK_DAY,
n2pos, n2.getLight(LIGHTBANK_DAY),
light_sources, modified_blocks);
n2.setLight(LIGHTBANK_DAY, 0);
2010-11-27 00:02:21 +01:00
setNode(n2pos, n2);
}
else
break;
}
}
2010-12-18 16:46:00 +01:00
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
2010-12-18 16:46:00 +01:00
/*
Spread light from all nodes that might be capable of doing so
*/
spreadLight(bank, light_sources, modified_blocks);
}
2010-12-19 15:51:45 +01:00
/*
Update information about whether day and night light differ
*/
for(core::map<v3s16, MapBlock*>::Iterator
i = modified_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
block->updateDayNightDiff();
}
/*
Add neighboring liquid nodes and the node itself if it is
liquid (=water node was added) to transform queue.
*/
v3s16 dirs[7] = {
v3s16(0,0,0), // self
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
};
for(u16 i=0; i<7; i++)
{
try
{
v3s16 p2 = p + dirs[i];
MapNode n2 = getNode(p2);
2011-08-03 19:00:25 +02:00
if(content_liquid(n2.getContent()) || n2.getContent() == CONTENT_AIR)
{
m_transforming_liquid.push_back(p2);
}
}catch(InvalidPositionException &e)
{
}
}
2010-11-27 00:02:21 +01:00
}
/*
*/
void Map::removeNodeAndUpdate(v3s16 p,
core::map<v3s16, MapBlock*> &modified_blocks)
{
/*PrintInfo(m_dout);
m_dout<<DTIME<<"Map::removeNodeAndUpdate(): p=("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
2010-11-27 00:02:21 +01:00
bool node_under_sunlight = true;
2010-11-27 00:02:21 +01:00
v3s16 toppos = p + v3s16(0,1,0);
2010-11-30 14:35:03 +01:00
// Node will be replaced with this
2011-07-23 15:55:26 +02:00
content_t replace_material = CONTENT_AIR;
2010-11-27 00:02:21 +01:00
/*
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);
2010-12-18 16:46:00 +01:00
if(topnode.getLight(LIGHTBANK_DAY) != LIGHT_SUN)
2010-11-27 00:02:21 +01:00
node_under_sunlight = false;
}
catch(InvalidPositionException &e)
{
}
core::map<v3s16, bool> light_sources;
2010-12-18 16:46:00 +01:00
enum LightBank banks[] =
{
LIGHTBANK_DAY,
LIGHTBANK_NIGHT
};
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
2010-12-18 16:46:00 +01:00
/*
Unlight neighbors (in case the node is a light source)
*/
unLightNeighbors(bank, p,
getNode(p).getLight(bank),
light_sources, modified_blocks);
}
2010-11-27 00:02:21 +01:00
2011-04-04 02:45:08 +02:00
/*
Remove node metadata
*/
removeNodeMetadata(p);
2010-11-27 00:02:21 +01:00
/*
2010-12-18 16:46:00 +01:00
Remove the node.
This also clears the lighting.
2010-11-27 00:02:21 +01:00
*/
2010-12-18 16:46:00 +01:00
2010-11-27 00:02:21 +01:00
MapNode n;
2011-07-23 15:55:26 +02:00
n.setContent(replace_material);
2010-11-27 00:02:21 +01:00
setNode(p, n);
2010-12-18 16:46:00 +01:00
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
2010-12-18 16:46:00 +01:00
/*
Recalculate lighting
*/
spreadLight(bank, light_sources, modified_blocks);
}
2010-11-27 00:02:21 +01:00
// Add the block of the removed node to modified_blocks
v3s16 blockpos = getNodeBlockPos(p);
MapBlock * block = getBlockNoCreate(blockpos);
assert(block != NULL);
modified_blocks.insert(blockpos, block);
/*
If the removed node was under sunlight, propagate the
sunlight down from it and then light all neighbors
of the propagated blocks.
*/
if(node_under_sunlight)
{
s16 ybottom = propagateSunlight(p, modified_blocks);
/*m_dout<<DTIME<<"Node was under sunlight. "
"Propagating sunlight";
m_dout<<DTIME<<" -> ybottom="<<ybottom<<std::endl;*/
s16 y = p.Y;
for(; y >= ybottom; y--)
{
v3s16 p2(p.X, y, p.Z);
/*m_dout<<DTIME<<"lighting neighbors of node ("
<<p2.X<<","<<p2.Y<<","<<p2.Z<<")"
<<std::endl;*/
2010-12-18 16:46:00 +01:00
lightNeighbors(LIGHTBANK_DAY, p2, modified_blocks);
2010-11-27 00:02:21 +01:00
}
}
else
{
// Set the lighting of this node to 0
2010-12-18 16:46:00 +01:00
// TODO: Is this needed? Lighting is cleared up there already.
2010-11-27 00:02:21 +01:00
try{
MapNode n = getNode(p);
2010-12-18 16:46:00 +01:00
n.setLight(LIGHTBANK_DAY, 0);
2010-11-27 00:02:21 +01:00
setNode(p, n);
}
catch(InvalidPositionException &e)
{
2011-02-23 01:49:57 +01:00
assert(0);
2010-11-27 00:02:21 +01:00
}
}
2010-12-18 16:46:00 +01:00
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
2010-12-18 16:46:00 +01:00
// Get the brightest neighbour node and propagate light from it
v3s16 n2p = getBrightestNeighbour(bank, p);
try{
MapNode n2 = getNode(n2p);
lightNeighbors(bank, n2p, modified_blocks);
}
catch(InvalidPositionException &e)
{
}
2010-11-27 00:02:21 +01:00
}
2010-12-19 15:51:45 +01:00
/*
Update information about whether day and night light differ
*/
for(core::map<v3s16, MapBlock*>::Iterator
i = modified_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
block->updateDayNightDiff();
}
/*
Add neighboring liquid nodes and this node to transform queue.
(it's vital for the node itself to get updated last.)
*/
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++)
{
try
{
v3s16 p2 = p + dirs[i];
MapNode n2 = getNode(p2);
2011-08-03 19:00:25 +02:00
if(content_liquid(n2.getContent()) || n2.getContent() == CONTENT_AIR)
{
m_transforming_liquid.push_back(p2);
}
}catch(InvalidPositionException &e)
{
}
}
2010-12-18 16:46:00 +01:00
}
2011-02-23 01:49:57 +01:00
bool Map::addNodeWithEvent(v3s16 p, MapNode n)
{
MapEditEvent event;
event.type = MEET_ADDNODE;
event.p = p;
event.n = n;
bool succeeded = true;
try{
core::map<v3s16, MapBlock*> modified_blocks;
addNodeAndUpdate(p, n, modified_blocks);
// Copy modified_blocks to event
for(core::map<v3s16, MapBlock*>::Iterator
i = modified_blocks.getIterator();
i.atEnd()==false; i++)
{
event.modified_blocks.insert(i.getNode()->getKey(), false);
}
}
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{
core::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++)
{
event.modified_blocks.insert(i.getNode()->getKey(), false);
}
}
catch(InvalidPositionException &e){
succeeded = false;
}
dispatchEvent(&event);
return succeeded;
}
2010-12-19 15:51:45 +01:00
bool Map::dayNightDiffed(v3s16 blockpos)
{
try{
v3s16 p = blockpos + v3s16(0,0,0);
MapBlock *b = getBlockNoCreate(p);
if(b->dayNightDiffed())
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->dayNightDiffed())
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->dayNightDiffed())
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->dayNightDiffed())
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->dayNightDiffed())
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,1,0);
MapBlock *b = getBlockNoCreate(p);
if(b->dayNightDiffed())
return true;
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,0,1);
MapBlock *b = getBlockNoCreate(p);
if(b->dayNightDiffed())
return true;
}
catch(InvalidPositionException &e){}
2010-12-19 15:51:45 +01:00
return false;
2010-11-27 00:02:21 +01:00
}
/*
Updates usage timers
*/
void Map::timerUpdate(float dtime, float unload_timeout,
core::list<v3s16> *unloaded_blocks)
2010-11-27 00:02:21 +01:00
{
bool save_before_unloading = (mapType() == MAPTYPE_SERVER);
core::list<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
2010-11-27 00:02:21 +01:00
core::map<v2s16, MapSector*>::Iterator si;
beginSave();
2010-11-27 00:02:21 +01:00
si = m_sectors.getIterator();
for(; si.atEnd() == false; si++)
{
MapSector *sector = si.getNode()->getValue();
bool all_blocks_deleted = true;
core::list<MapBlock*> blocks;
sector->getBlocks(blocks);
for(core::list<MapBlock*>::Iterator i = blocks.begin();
i != blocks.end(); i++)
{
MapBlock *block = (*i);
block->incrementUsageTimer(dtime);
if(block->getUsageTimer() > unload_timeout)
{
v3s16 p = block->getPos();
// Save if modified
if(block->getModified() != MOD_STATE_CLEAN
&& save_before_unloading)
{
saveBlock(block);
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;
}
}
if(all_blocks_deleted)
{
sector_deletion_queue.push_back(si.getNode()->getKey());
}
2010-11-27 00:02:21 +01:00
}
endSave();
// Finally delete the empty sectors
deleteSectors(sector_deletion_queue);
if(deleted_blocks_count != 0)
{
PrintInfo(dstream); // ServerMap/ClientMap:
dstream<<"Unloaded "<<deleted_blocks_count
<<" blocks from memory";
if(save_before_unloading)
dstream<<", of which "<<saved_blocks_count<<" were written";
dstream<<"."<<std::endl;
2010-11-27 00:02:21 +01:00
}
}
void Map::deleteSectors(core::list<v2s16> &list)
2010-11-27 00:02:21 +01:00
{
core::list<v2s16>::Iterator j;
for(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);
delete sector;
2010-11-27 00:02:21 +01:00
}
}
#if 0
void Map::unloadUnusedData(float timeout,
2010-11-27 00:02:21 +01:00
core::list<v3s16> *deleted_blocks)
{
core::list<v2s16> sector_deletion_queue;
u32 deleted_blocks_count = 0;
u32 saved_blocks_count = 0;
core::map<v2s16, MapSector*>::Iterator si = m_sectors.getIterator();
for(; si.atEnd() == false; si++)
{
MapSector *sector = si.getNode()->getValue();
bool all_blocks_deleted = true;
core::list<MapBlock*> blocks;
sector->getBlocks(blocks);
for(core::list<MapBlock*>::Iterator i = blocks.begin();
i != blocks.end(); i++)
{
MapBlock *block = (*i);
if(block->getUsageTimer() > timeout)
{
// Save if modified
if(block->getModified() != MOD_STATE_CLEAN)
{
saveBlock(block);
saved_blocks_count++;
}
2011-06-25 23:03:58 +02:00
// Delete from memory
sector->deleteBlock(block);
deleted_blocks_count++;
}
else
{
all_blocks_deleted = false;
}
}
if(all_blocks_deleted)
{
sector_deletion_queue.push_back(si.getNode()->getKey());
}
}
deleteSectors(sector_deletion_queue);
dstream<<"Map: Unloaded "<<deleted_blocks_count<<" blocks from memory"
<<", of which "<<saved_blocks_count<<" were wr."
<<std::endl;
//return sector_deletion_queue.getSize();
//return deleted_blocks_count;
2010-11-27 00:02:21 +01:00
}
#endif
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;
};
void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
{
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)
dstream<<"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
UniqueQueue<v3s16> must_reflow;
2011-08-22 12:19:07 +02:00
// List of MapBlocks that will require a lighting update (due to lava)
core::map<v3s16, MapBlock*> lighting_modified_blocks;
2011-08-16 19:56:57 +02:00
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 * 3)
break;
loopcount++;
2011-01-23 16:29:15 +01:00
/*
Get a queued transforming liquid node
*/
v3s16 p0 = m_transforming_liquid.pop_front();
MapNode n0 = getNodeNoEx(p0);
/*
Collect information about current node
*/
s8 liquid_level = -1;
u8 liquid_kind = CONTENT_IGNORE;
LiquidType liquid_type = content_features(n0.getContent()).liquid_type;
switch (liquid_type) {
case LIQUID_SOURCE:
2011-08-16 08:31:33 +02:00
liquid_level = LIQUID_LEVEL_SOURCE;
liquid_kind = content_features(n0.getContent()).liquid_alternative_flowing;
break;
case LIQUID_FLOWING:
liquid_level = (n0.param2 & LIQUID_LEVEL_MASK);
liquid_kind = n0.getContent();
break;
case LIQUID_NONE:
// if this is an air node, it *could* be transformed into a liquid. otherwise,
// continue with the next node.
if (n0.getContent() != CONTENT_AIR)
continue;
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};
switch (content_features(nb.n.getContent()).liquid_type) {
case LIQUID_NONE:
if (nb.n.getContent() == CONTENT_AIR) {
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;
}
break;
case LIQUID_SOURCE:
// if this node is not (yet) of a liquid type, choose the first liquid type we encounter
if (liquid_kind == CONTENT_AIR)
liquid_kind = content_features(nb.n.getContent()).liquid_alternative_flowing;
if (content_features(nb.n.getContent()).liquid_alternative_flowing !=liquid_kind) {
neutrals[num_neutrals++] = nb;
} else {
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 = content_features(nb.n.getContent()).liquid_alternative_flowing;
if (content_features(nb.n.getContent()).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;
if (num_sources >= 2 || 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 = content_features(liquid_kind).liquid_alternative_source;
} else if (num_sources == 1 && sources[0].t != NEIGHBOR_LOWER) {
// liquid_kind is set properly, see above
new_node_content = liquid_kind;
2011-08-16 19:56:57 +02:00
max_node_level = new_node_level = LIQUID_LEVEL_MAX;
} 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 &&
2011-08-16 19:56:57 +02:00
nb_liquid_level > 0 && nb_liquid_level - 1 > max_node_level) {
max_node_level = nb_liquid_level - 1;
}
break;
}
}
2011-08-16 20:38:44 +02:00
u8 viscosity = content_features(liquid_kind).liquid_viscosity;
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
new_node_level = max_node_level;
if (new_node_level >= 0)
new_node_content = liquid_kind;
else
new_node_content = CONTENT_AIR;
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() && (content_features(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
*/
bool flow_down_enabled = (flowing_down && ((n0.param2 & LIQUID_FLOW_DOWN_MASK) != LIQUID_FLOW_DOWN_MASK));
if (content_features(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);
setNode(p0, n0);
v3s16 blockpos = getNodeBlockPos(p0);
MapBlock *block = getBlockNoCreateNoEx(blockpos);
2011-08-22 12:19:07 +02:00
if(block != NULL) {
modified_blocks.insert(blockpos, block);
2011-08-22 12:19:07 +02:00
// If node emits light, MapBlock requires lighting update
if(content_features(n0).light_source != 0)
lighting_modified_blocks[block->getPos()] = block;
}
/*
enqueue neighbors for update if neccessary
*/
switch (content_features(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;
}
}
2011-01-17 20:18:08 +01:00
//dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
2011-08-16 19:56:57 +02:00
while (must_reflow.size() > 0)
m_transforming_liquid.push_back(must_reflow.pop_front());
2011-08-22 12:19:07 +02:00
updateLighting(lighting_modified_blocks, modified_blocks);
}
2011-04-04 02:45:08 +02:00
NodeMetadata* Map::getNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
2011-04-04 02:45:08 +02:00
{
dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
<<std::endl;
return NULL;
2011-04-04 02:45:08 +02:00
}
NodeMetadata *meta = block->m_node_metadata.get(p_rel);
return meta;
}
2011-04-04 02:45:08 +02:00
void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
{
dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
<<std::endl;
return;
}
block->m_node_metadata.set(p_rel, meta);
}
void Map::removeNodeMetadata(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
MapBlock *block = getBlockNoCreateNoEx(blockpos);
if(block == NULL)
{
dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
<<std::endl;
return;
}
block->m_node_metadata.remove(p_rel);
}
2011-04-05 01:56:29 +02:00
void Map::nodeMetadataStep(float dtime,
core::map<v3s16, MapBlock*> &changed_blocks)
{
/*
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;
}
}
}
2010-11-27 00:02:21 +01:00
/*
ServerMap
*/
2011-02-05 13:55:16 +01:00
ServerMap::ServerMap(std::string savedir):
2010-11-27 00:02:21 +01:00
Map(dout_server),
m_seed(0),
m_map_metadata_changed(true),
m_database(NULL),
m_database_read(NULL),
m_database_write(NULL)
2010-11-27 00:02:21 +01:00
{
dstream<<__FUNCTION_NAME<<std::endl;
//m_chunksize = 8; // Takes a few seconds
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");
}
/*
Experimental and debug stuff
*/
{
}
/*
Try to load map; if not found, create a new one.
*/
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)
{
dstream<<DTIME<<"Server: Empty save directory is valid."
<<std::endl;
m_map_saving_enabled = true;
}
else
{
2011-04-10 21:50:31 +02:00
try{
// Load map metadata (seed, chunksize)
loadMapMeta();
}
catch(FileNotGoodException &e){
dstream<<DTIME<<"WARNING: Could not load map metadata"
//<<" Disabling chunk-based generator."
<<std::endl;
//m_chunksize = 0;
}
/*try{
2011-04-10 21:50:31 +02:00
// Load chunk metadata
loadChunkMeta();
}
catch(FileNotGoodException &e){
dstream<<DTIME<<"WARNING: Could not load chunk metadata."
<<" Disabling chunk-based generator."
<<std::endl;
2011-04-10 21:50:31 +02:00
m_chunksize = 0;
}*/
2010-11-27 00:02:21 +01:00
2011-02-11 18:55:42 +01:00
/*dstream<<DTIME<<"Server: Successfully loaded chunk "
"metadata and sector (0,0) from "<<savedir<<
2010-11-27 00:02:21 +01:00
", assuming valid save directory."
2011-02-11 18:55:42 +01:00
<<std::endl;*/
dstream<<DTIME<<"INFO: Server: Successfully loaded map "
<<"and chunk metadata from "<<savedir
<<", assuming valid save directory."
2010-11-27 00:02:21 +01:00
<<std::endl;
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)
{
2011-02-11 18:55:42 +01:00
dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
2010-11-27 00:02:21 +01:00
<<", exception: "<<e.what()<<std::endl;
2011-02-11 18:55:42 +01:00
dstream<<"Please remove the map or fix it."<<std::endl;
dstream<<"WARNING: Map saving will be disabled."<<std::endl;
2010-11-27 00:02:21 +01:00
}
2011-02-11 18:55:42 +01:00
dstream<<DTIME<<"INFO: 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(false);
}
ServerMap::~ServerMap()
{
dstream<<__FUNCTION_NAME<<std::endl;
2010-11-27 00:02:21 +01:00
try
{
if(m_map_saving_enabled)
{
// Save only changed parts
save(true);
dstream<<DTIME<<"Server: saved map to "<<m_savedir<<std::endl;
}
else
{
dstream<<DTIME<<"Server: map not saved"<<std::endl;
}
}
catch(std::exception &e)
{
dstream<<DTIME<<"Server: Failed to save map to "<<m_savedir
<<", exception: "<<e.what()<<std::endl;
}
/*
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);
#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
2010-11-27 00:02:21 +01:00
}
2011-06-25 17:35:32 +02:00
void ServerMap::initBlockMake(mapgen::BlockMakeData *data, v3s16 blockpos)
{
bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
2011-07-24 11:12:55 +02:00
if(enable_mapgen_debug_info)
dstream<<"initBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
<<blockpos.Z<<")"<<std::endl;
// Do nothing if not inside limits (+-1 because of neighbors)
if(blockpos_over_limit(blockpos - v3s16(1,1,1)) ||
blockpos_over_limit(blockpos + v3s16(1,1,1)))
{
data->no_op = true;
return;
}
data->no_op = false;
data->seed = m_seed;
data->blockpos = blockpos;
2011-01-15 12:50:13 +01:00
/*
Create the whole area of this and the neighboring blocks
*/
{
//TimeTaker timer("initBlockMake() create area");
for(s16 x=-1; x<=1; x++)
for(s16 z=-1; z<=1; z++)
2010-12-25 15:04:51 +01:00
{
v2s16 sectorpos(blockpos.X+x, blockpos.Z+z);
// Sector metadata is loaded from disk if not already loaded.
ServerMapSector *sector = createSector(sectorpos);
assert(sector);
for(s16 y=-1; y<=1; y++)
2010-12-25 15:04:51 +01:00
{
v3s16 p(blockpos.X+x, blockpos.Y+y, blockpos.Z+z);
//MapBlock *block = createBlock(p);
// 1) get from memory, 2) load from disk
MapBlock *block = emergeBlock(p, false);
// 3) create a blank one
if(block == NULL)
{
block = createBlock(p);
/*
Block gets sunlight if this is true.
Refer to the map generator heuristics.
*/
bool ug = mapgen::block_is_underground(data->seed, p);
block->setIsUnderground(ug);
}
2011-01-08 13:08:48 +01:00
// Lighting will not be valid after make_chunk is called
block->setLightingExpired(true);
// Lighting will be calculated
//block->setLightingExpired(false);
2011-01-08 13:08:48 +01:00
}
2010-12-25 15:04:51 +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
*/
// The area that contains this block and it's neighbors
v3s16 bigarea_blocks_min = blockpos - v3s16(1,1,1);
v3s16 bigarea_blocks_max = blockpos + v3s16(1,1,1);
2011-06-25 17:35:32 +02:00
data->vmanip = new ManualMapVoxelManipulator(this);
//data->vmanip->setMap(this);
2011-01-15 12:50:13 +01:00
// Add the area
2010-11-27 00:02:21 +01:00
{
//TimeTaker timer("initBlockMake() initialEmerge");
2011-06-25 17:35:32 +02:00
data->vmanip->initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
}
2010-12-13 02:19:12 +01:00
// Data is ready now.
}
2011-06-25 17:35:32 +02:00
MapBlock* ServerMap::finishBlockMake(mapgen::BlockMakeData *data,
core::map<v3s16, MapBlock*> &changed_blocks)
{
v3s16 blockpos = data->blockpos;
/*dstream<<"finishBlockMake(): ("<<blockpos.X<<","<<blockpos.Y<<","
<<blockpos.Z<<")"<<std::endl;*/
if(data->no_op)
{
//dstream<<"finishBlockMake(): no-op"<<std::endl;
return NULL;
2010-11-27 00:02:21 +01:00
}
bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
/*dstream<<"Resulting vmanip:"<<std::endl;
data->vmanip.print(dstream);*/
2011-01-15 12:50:13 +01:00
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
*/
{
// 70ms @cs=8
//TimeTaker timer("finishBlockMake() blitBackAll");
2011-06-25 17:35:32 +02:00
data->vmanip->blitBackAll(&changed_blocks);
}
if(enable_mapgen_debug_info)
dstream<<"finishBlockMake: changed_blocks.size()="
<<changed_blocks.size()<<std::endl;
/*
Copy transforming liquid information
*/
while(data->transforming_liquid.size() > 0)
{
v3s16 p = data->transforming_liquid.pop_front();
m_transforming_liquid.push_back(p);
}
/*
Get central block
*/
MapBlock *block = getBlockNoCreateNoEx(data->blockpos);
assert(block);
/*
Set is_underground flag for lighting with sunlight.
Refer to map generator heuristics.
NOTE: This is done in initChunkMake
*/
//block->setIsUnderground(mapgen::block_is_underground(data->seed, blockpos));
/*
Add sunlight to central block.
This makes in-dark-spawning monsters to not flood the whole thing.
Do not spread the light, though.
*/
/*core::map<v3s16, bool> light_sources;
bool black_air_left = false;
block->propagateSunlight(light_sources, true, &black_air_left);*/
2011-01-15 12:50:13 +01:00
2010-11-27 00:02:21 +01:00
/*
NOTE: Lighting and object adding shouldn't really be here, but
lighting is a bit tricky to move properly to makeBlock.
TODO: Do this the right way anyway, that is, move it to makeBlock.
- There needs to be some way for makeBlock to report back if
the lighting update is going further down because of the
new block blocking light
2010-11-27 00:02:21 +01:00
*/
/*
Update lighting
NOTE: This takes ~60ms, TODO: Investigate why
*/
2010-11-27 00:02:21 +01:00
{
2011-06-26 01:34:36 +02:00
TimeTaker t("finishBlockMake lighting update");
core::map<v3s16, MapBlock*> lighting_update_blocks;
#if 1
2011-06-26 01:34:36 +02:00
// Center block
lighting_update_blocks.insert(block->getPos(), block);
/*{
s16 x = 0;
s16 z = 0;
v3s16 p = block->getPos()+v3s16(x,1,z);
lighting_update_blocks[p] = getBlockNoCreateNoEx(p);
}*/
#endif
#if 0
2011-06-26 01:34:36 +02:00
// All modified blocks
// NOTE: Should this be done? If this is not done, then the lighting
// of the others will be updated in a different place, one by one, i
// think... or they might not? Well, at least they are left marked as
// "lighting expired"; it seems that is not handled at all anywhere,
// so enabling this will slow it down A LOT because otherwise it
// would not do this at all. This causes the black trees.
2011-06-26 01:34:36 +02:00
for(core::map<v3s16, MapBlock*>::Iterator
i = changed_blocks.getIterator();
i.atEnd() == false; i++)
{
lighting_update_blocks.insert(i.getNode()->getKey(),
i.getNode()->getValue());
}
/*// Also force-add all the upmost blocks for proper sunlight
for(s16 x=-1; x<=1; x++)
for(s16 z=-1; z<=1; z++)
{
v3s16 p = block->getPos()+v3s16(x,1,z);
lighting_update_blocks[p] = getBlockNoCreateNoEx(p);
}*/
#endif
2011-06-26 01:34:36 +02:00
updateLighting(lighting_update_blocks, changed_blocks);
/*
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=-1; x<=1; x++)
for(s16 y=-1; y<=1; y++)
for(s16 z=-1; z<=1; z++)
{
v3s16 p = block->getPos()+v3s16(x,y,z);
getBlockNoCreateNoEx(p)->setLightingExpired(false);
}
if(enable_mapgen_debug_info == false)
t.stop(true); // Hide output
2011-06-25 15:32:09 +02:00
}
2011-06-26 01:34:36 +02:00
/*
Add random objects to block
*/
mapgen::add_random_objects(block);
/*
Go through changed blocks
*/
for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
assert(block);
/*
Update day/night difference cache of the MapBlocks
*/
block->updateDayNightDiff();
/*
Set block as modified
*/
block->raiseModified(MOD_STATE_WRITE_NEEDED);
}
/*
Set central block as generated
*/
block->setGenerated(true);
/*
Save changed parts of map
NOTE: Will be saved later.
*/
//save(true);
/*dstream<<"finishBlockMake() done for ("<<blockpos.X<<","<<blockpos.Y<<","
<<blockpos.Z<<")"<<std::endl;*/
#if 0
if(enable_mapgen_debug_info)
{
/*
Analyze resulting blocks
*/
for(s16 x=-1; x<=1; x++)
for(s16 y=-1; y<=1; y++)
for(s16 z=-1; z<=1; z++)
{
v3s16 p = block->getPos()+v3s16(x,y,z);
MapBlock *block = getBlockNoCreateNoEx(p);
char spos[20];
snprintf(spos, 20, "(%2d,%2d,%2d)", x, y, z);
dstream<<"Generated "<<spos<<": "
<<analyze_block(block)<<std::endl;
}
}
#endif
return block;
}
2010-12-22 15:30:23 +01:00
ServerMapSector * ServerMap::createSector(v2s16 p2d)
{
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;
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
{
dstream<<"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
*/
if(p2d.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p2d.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
throw InvalidPositionException("createSector(): pos. over limit");
/*
Generate blank sector
*/
sector = new ServerMapSector(this, p2d);
2010-11-27 00:02:21 +01:00
// Sector position on map in nodes
v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
2010-11-27 00:02:21 +01:00
/*
Insert to container
2010-11-27 00:02:21 +01:00
*/
m_sectors.insert(p2d, sector);
return sector;
}
/*
This is a quick-hand function for calling makeBlock().
*/
MapBlock * ServerMap::generateBlock(
v3s16 p,
core::map<v3s16, MapBlock*> &modified_blocks
)
{
DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z);
/*dstream<<"generateBlock(): "
<<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
2010-11-27 00:02:21 +01:00
bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
2011-06-25 15:32:09 +02:00
TimeTaker timer("generateBlock");
//MapBlock *block = original_dummy;
v2s16 p2d(p.X, p.Z);
v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
/*
Do not generate over-limit
*/
if(blockpos_over_limit(p))
{
dstream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
throw InvalidPositionException("generateBlock(): pos. over limit");
}
/*
Create block make data
*/
2011-06-25 17:35:32 +02:00
mapgen::BlockMakeData data;
initBlockMake(&data, p);
/*
Generate block
*/
{
TimeTaker t("mapgen::make_block()");
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)
{
dstream<<"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;
if(y0%2==0)
2011-07-23 15:55:26 +02:00
n.setContent(CONTENT_AIR);
else
2011-07-23 15:55:26 +02:00
n.setContent(CONTENT_STONE);
block->setNode(v3s16(x0,y0,z0), n);
}
}
}
#endif
if(enable_mapgen_debug_info == false)
timer.stop(true); // Hide output
return block;
}
MapBlock * ServerMap::createBlock(v3s16 p)
{
DSTACKF("%s: p=(%d,%d,%d)",
__FUNCTION_NAME, p.X, p.Y, p.Z);
/*
Do not create over-limit
*/
if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| 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;
/*
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)
{
dstream<<"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)
{
dstream<<"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 allow_generate)
{
DSTACKF("%s: p=(%d,%d,%d), allow_generate=%d",
__FUNCTION_NAME,
p.X, p.Y, p.Z, allow_generate);
{
MapBlock *block = getBlockNoCreateNoEx(p);
if(block && block->isDummy() == false)
return block;
}
{
MapBlock *block = loadBlock(p);
if(block)
return block;
}
if(allow_generate)
{
core::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
for(core::map<v3s16, MapBlock*>::Iterator
i = modified_blocks.getIterator();
i.atEnd()==false; i++)
{
event.modified_blocks.insert(i.getNode()->getKey(), false);
}
// Queue event
dispatchEvent(&event);
return block;
}
}
return NULL;
}
#if 0
/*
Do not generate over-limit
*/
if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
|| p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
throw InvalidPositionException("emergeBlock(): pos. over limit");
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.
*/
ServerMapSector *sector;
try{
sector = createSector(p2d);
//sector = emergeSector(p2d, changed_blocks);
}
catch(InvalidPositionException &e)
{
dstream<<"emergeBlock: createSector() failed: "
<<e.what()<<std::endl;
2011-02-14 01:54:15 +01:00
dstream<<"Path to failed sector: "<<getSectorDir(p2d)
<<std::endl
<<"You could try to delete it."<<std::endl;
throw e;
}
catch(VersionMismatchException &e)
{
dstream<<"emergeBlock: createSector() failed: "
<<e.what()<<std::endl;
dstream<<"Path to failed sector: "<<getSectorDir(p2d)
<<std::endl
<<"You could try to delete it."<<std::endl;
throw e;
}
/*
Try to get a block from the sector
*/
bool does_not_exist = false;
bool lighting_expired = false;
MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
// If not found, try loading from disk
if(block == NULL)
{
block = loadBlock(p);
}
// Handle result
if(block == NULL)
{
does_not_exist = true;
}
else if(block->isDummy() == true)
{
does_not_exist = true;
}
else if(block->getLightingExpired())
{
lighting_expired = true;
}
else
{
// Valid block
//dstream<<"emergeBlock(): Returning already valid block"<<std::endl;
return block;
}
/*
If block was not found on disk and not going to generate a
new one, make sure there is a dummy block in place.
*/
if(only_from_disk && (does_not_exist || lighting_expired))
{
//dstream<<"emergeBlock(): Was not on disk but not generating"<<std::endl;
if(block == NULL)
{
// Create dummy block
block = new MapBlock(this, p, true);
// Add block to sector
sector->insertBlock(block);
}
// Done.
return block;
}
//dstream<<"Not found on disk, generating."<<std::endl;
// 0ms
//TimeTaker("emergeBlock() generate");
//dstream<<"emergeBlock(): Didn't find valid block -> making one"<<std::endl;
/*
If the block doesn't exist, generate the block.
*/
if(does_not_exist)
{
block = generateBlock(p, block, sector, changed_blocks,
lighting_invalidated_blocks);
}
if(lighting_expired)
{
lighting_invalidated_blocks.insert(p, block);
}
2010-11-27 00:02:21 +01:00
#if 0
2011-01-15 12:50:13 +01:00
/*
Initially update sunlight
*/
{
core::map<v3s16, bool> light_sources;
bool black_air_left = false;
bool bottom_invalid =
block->propagateSunlight(light_sources, true,
&black_air_left);
2011-01-15 12:50:13 +01:00
// If sunlight didn't reach everywhere and part of block is
// above ground, lighting has to be properly updated
//if(black_air_left && some_part_underground)
if(black_air_left)
2011-01-15 12:50:13 +01:00
{
lighting_invalidated_blocks[block->getPos()] = block;
}
if(bottom_invalid)
{
lighting_invalidated_blocks[block->getPos()] = block;
}
2011-01-15 12:50:13 +01:00
}
#endif
2011-01-15 12:50:13 +01:00
2010-11-27 00:02:21 +01:00
return block;
}
#endif
2010-11-27 00:02:21 +01:00
2011-02-23 01:49:57 +01:00
s16 ServerMap::findGroundLevel(v2s16 p2d)
{
#if 0
2011-02-23 01:49:57 +01:00
/*
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);
2011-07-23 15:55:26 +02:00
if(n.getContent() != CONTENT_IGNORE)
2011-02-23 01:49:57 +01:00
break;
}
if(p.Y == min)
goto plan_b;
// If this node is not air, go to plan b
2011-07-23 15:55:26 +02:00
if(getNodeNoEx(p).getContent() != CONTENT_AIR)
2011-02-23 01:49:57 +01:00
goto plan_b;
// Search existing walkable and return it
for(; p.Y>min; p.Y--)
{
MapNode n = getNodeNoEx(p);
2011-07-23 15:55:26 +02:00
if(content_walkable(n.d) && n.getContent() != CONTENT_IGNORE)
2011-02-23 01:49:57 +01:00
return p.Y;
}
2011-02-23 01:49:57 +01:00
// Move to plan b
plan_b:
#endif
2011-02-23 01:49:57 +01:00
/*
Determine from map generator noise functions
2011-02-23 01:49:57 +01:00
*/
s16 level = mapgen::find_ground_level_from_noise(m_seed, p2d, 1);
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
}
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
dstream<<"Server: Database structure was created";
}
void ServerMap::verifyDatabase() {
if(m_database)
return;
{
std::string dbp = m_savedir + "/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) {
dstream<<"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) {
dstream<<"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) {
dstream<<"WARNING: Database write statment failed to prepare: "<<sqlite3_errmsg(m_database)<<std::endl;
throw FileNotGoodException("Cannot prepare write statement");
}
dstream<<"Server: Database opened"<<std::endl;
}
}
bool ServerMap::loadFromFolders() {
if(!m_database && !fs::PathExists(m_savedir + "/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)
2010-11-27 00:02:21 +01:00
{
if(fs::CreateAllDirs(path) == false)
2010-11-27 00:02:21 +01:00
{
m_dout<<DTIME<<"ServerMap: Failed to create directory "
<<"\""<<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 + "/sectors/" + cc;
case 2:
snprintf(cc, 9, "%.3x/%.3x",
(unsigned int)pos.X&0xfff,
(unsigned int)pos.Y&0xfff);
2010-11-27 00:02:21 +01:00
return m_savedir + "/sectors2/" + cc;
default:
assert(false);
}
2010-11-27 00:02:21 +01:00
}
v2s16 ServerMap::getSectorPos(std::string dirname)
{
unsigned int x, y;
int r;
size_t spos = dirname.rfind('/') + 1;
assert(spos != std::string::npos);
if(dirname.size() - spos == 8)
{
// Old layout
r = sscanf(dirname.substr(spos).c_str(), "%4x%4x", &x, &y);
}
else if(dirname.size() - spos == 3)
{
// New layout
r = sscanf(dirname.substr(spos-4).c_str(), "%3x/%3x", &x, &y);
// Sign-extend the 12 bit values up to 16 bits...
if(x&0x800) x|=0xF000;
if(y&0x800) y|=0xF000;
}
else
{
assert(false);
}
assert(r == 2);
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;
}
2010-11-27 00:02:21 +01:00
void ServerMap::save(bool only_changed)
{
DSTACK(__FUNCTION_NAME);
if(m_map_saving_enabled == false)
{
dstream<<DTIME<<"WARNING: Not saving map, saving disabled."<<std::endl;
return;
}
if(only_changed == false)
dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
if(only_changed == false || m_map_metadata_changed)
{
saveMapMeta();
}
2011-04-10 21:50:31 +02: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
2010-11-27 00:02:21 +01:00
beginSave();
2010-11-27 00:02:21 +01:00
core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
for(; i.atEnd() == false; i++)
{
ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
assert(sector->getId() == MAPSECTOR_SERVER);
2011-02-05 13:55:16 +01:00
if(sector->differs_from_disk || only_changed == false)
2010-11-27 00:02:21 +01:00
{
2011-02-05 13:55:16 +01:00
saveSectorMeta(sector);
sector_meta_count++;
2010-11-27 00:02:21 +01:00
}
2011-02-05 13:55:16 +01:00
core::list<MapBlock*> blocks;
sector->getBlocks(blocks);
core::list<MapBlock*>::Iterator j;
//sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL);
2011-02-05 13:55:16 +01:00
for(j=blocks.begin(); j!=blocks.end(); j++)
2010-11-27 00:02:21 +01:00
{
2011-02-05 13:55:16 +01:00
MapBlock *block = *j;
block_count_all++;
if(block->getModified() >= MOD_STATE_WRITE_NEEDED
|| only_changed == false)
2010-11-27 00:02:21 +01:00
{
2011-02-05 13:55:16 +01:00
saveBlock(block);
block_count++;
/*dstream<<"ServerMap: Written block ("
<<block->getPos().X<<","
<<block->getPos().Y<<","
<<block->getPos().Z<<")"
<<std::endl;*/
2010-11-27 00:02:21 +01:00
}
//sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL);
2010-11-27 00:02:21 +01:00
}
}
endSave();
2010-11-27 00:02:21 +01:00
/*
Only print if something happened or saved whole map
*/
if(only_changed == false || sector_meta_count != 0
2010-12-21 01:25:47 +01:00
|| block_count != 0)
2010-11-27 00:02:21 +01:00
{
dstream<<DTIME<<"ServerMap: Written: "
<<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;
}
}
2011-02-11 18:55:42 +01:00
void ServerMap::saveMapMeta()
{
DSTACK(__FUNCTION_NAME);
dstream<<"INFO: ServerMap::saveMapMeta(): "
<<"seed="<<m_seed
2011-02-11 18:55:42 +01:00
<<std::endl;
createDirs(m_savedir);
2011-02-11 18:55:42 +01:00
2011-02-11 19:37:54 +01:00
std::string fullpath = m_savedir + "/map_meta.txt";
2011-02-11 18:55:42 +01:00
std::ofstream os(fullpath.c_str(), std::ios_base::binary);
if(os.good() == false)
{
dstream<<"ERROR: ServerMap::saveMapMeta(): "
<<"could not open"<<fullpath<<std::endl;
throw FileNotGoodException("Cannot open chunk metadata");
}
Settings params;
params.setU64("seed", m_seed);
params.writeLines(os);
os<<"[end_of_params]\n";
m_map_metadata_changed = false;
2011-02-11 18:55:42 +01:00
}
void ServerMap::loadMapMeta()
{
DSTACK(__FUNCTION_NAME);
dstream<<"INFO: ServerMap::loadMapMeta(): Loading map metadata"
2011-02-11 18:55:42 +01:00
<<std::endl;
2011-02-11 19:37:54 +01:00
std::string fullpath = m_savedir + "/map_meta.txt";
2011-02-11 18:55:42 +01:00
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
{
dstream<<"ERROR: ServerMap::loadMapMeta(): "
<<"could not open"<<fullpath<<std::endl;
throw FileNotGoodException("Cannot open map metadata");
2011-02-11 18:55:42 +01:00
}
Settings params;
for(;;)
{
if(is.eof())
throw SerializationError
("ServerMap::loadMapMeta(): [end_of_params] not found");
std::string line;
std::getline(is, line);
std::string trimmedline = trim(line);
if(trimmedline == "[end_of_params]")
break;
params.parseConfigLine(line);
}
m_seed = params.getU64("seed");
dstream<<"INFO: ServerMap::loadMapMeta(): "
<<"seed="<<m_seed
2011-02-11 18:55:42 +01:00
<<std::endl;
}
2010-11-27 00:02:21 +01:00
void ServerMap::saveSectorMeta(ServerMapSector *sector)
{
DSTACK(__FUNCTION_NAME);
// Format used for writing
u8 version = SER_FMT_VER_HIGHEST;
// Get destination
v2s16 pos = sector->getPos();
std::string dir = getSectorDir(pos);
createDirs(dir);
2010-11-27 00:02:21 +01:00
2011-02-11 19:37:54 +01:00
std::string fullpath = dir + "/meta";
2010-11-27 00:02:21 +01:00
std::ofstream o(fullpath.c_str(), std::ios_base::binary);
if(o.good() == false)
2011-02-11 19:37:54 +01:00
throw FileNotGoodException("Cannot open sector metafile");
2010-11-27 00:02:21 +01:00
sector->serialize(o, version);
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);
// Get destination
v2s16 p2d = getSectorPos(sectordir);
2011-04-10 23:19:40 +02:00
ServerMapSector *sector = NULL;
std::string fullpath = sectordir + "/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
{
/*dstream<<"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-04-10 23:24:32 +02:00
sector = new ServerMapSector(this, p2d);
m_sectors.insert(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
(is, this, p2d, m_sectors);
if(save_after_load)
saveSectorMeta(sector);
2011-04-10 23:19:40 +02: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);
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);
}
try{
sector = loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
return false;
}
catch(FileNotGoodException &e)
{
return false;
}
catch(std::exception &e)
{
return false;
}
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;
}
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)
{
dstream<<"Sector converted to new layout - deleting "<<
sectordir1<<std::endl;
fs::RecursiveDelete(sectordir1);
}
2010-11-27 00:02:21 +01:00
return true;
}
#endif
void ServerMap::beginSave() {
verifyDatabase();
if(sqlite3_exec(m_database, "BEGIN;", NULL, NULL, NULL) != SQLITE_OK)
dstream<<"WARNING: beginSave() failed, saving might be slow.";
}
void ServerMap::endSave() {
verifyDatabase();
if(sqlite3_exec(m_database, "COMMIT;", NULL, NULL, NULL) != SQLITE_OK)
dstream<<"WARNING: endSave() failed, map might not have saved.";
}
2010-11-27 00:02:21 +01:00
void ServerMap::saveBlock(MapBlock *block)
{
DSTACK(__FUNCTION_NAME);
/*
Dummy blocks are not written
*/
if(block->isDummy())
{
/*v3s16 p = block->getPos();
dstream<<"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+"/"+getBlockFilename(p3d);
2010-11-27 00:02:21 +01:00
std::ofstream o(fullpath.c_str(), std::ios_base::binary);
if(o.good() == false)
throw FileNotGoodException("Cannot open block data");
#endif
2010-11-27 00:02:21 +01:00
/*
[0] u8 serialization version
[1] data
*/
verifyDatabase();
std::ostringstream o(std::ios_base::binary);
2010-11-27 00:02:21 +01:00
o.write((char*)&version, 1);
// Write basic data
2010-11-27 00:02:21 +01:00
block->serialize(o, version);
2011-04-10 03:15:10 +02:00
// Write extra data stored on disk
block->serializeDiskExtra(o, version);
// 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)
dstream<<"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
dstream<<"WARNING: Block data failed to bind: "<<sqlite3_errmsg(m_database)<<std::endl;
int written = sqlite3_step(m_database_write);
if(written != SQLITE_DONE)
dstream<<"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();
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+"/"+blockfile;
2010-11-29 16:55:07 +01:00
try{
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);
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;
}
// Read basic data
block->deSerialize(is, version);
2010-11-27 00:02:21 +01:00
// Read extra data stored on disk
block->deSerializeDiskExtra(is, version);
2011-04-10 03:15:10 +02:00
// 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)
{
saveBlock(block);
}
// 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)
{
dstream<<"WARNING: Invalid block data on disk "
<<"fullpath="<<fullpath
<<" (SerializationError). "
<<"what()="<<e.what()
2010-11-29 16:55:07 +01:00
<<std::endl;
//" Ignoring. A new one will be generated.
assert(0);
// 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);
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;
}
// Read basic data
block->deSerialize(is, version);
// Read extra data stored on disk
block->deSerializeDiskExtra(is, version);
// 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)
{
saveBlock(block);
}
// We just loaded it from, so it's up-to-date.
block->resetModified();
}
catch(SerializationError &e)
{
dstream<<"WARNING: Invalid block data in database "
<<" (SerializationError). "
<<"what()="<<e.what()
<<std::endl;
//" Ignoring. A new one will be generated.
assert(0);
// TODO: Copy to a backup database.
}
}
MapBlock* ServerMap::loadBlock(v3s16 blockpos)
{
DSTACK(__FUNCTION_NAME);
v2s16 p2d(blockpos.X, blockpos.Z);
if(!loadFromFolders()) {
verifyDatabase();
if(sqlite3_bind_int64(m_database_read, 1, getBlockAsInteger(blockpos)) != SQLITE_OK)
dstream<<"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);
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
}
// 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);
}
/*
Make sure sector is loaded
*/
MapSector *sector = getSectorNoGenerateNoEx(p2d);
if(sector == NULL)
{
try{
sector = loadSectorMeta(sectordir, loadlayout != 2);
}
catch(InvalidFilenameException &e)
{
return false;
}
catch(FileNotGoodException &e)
{
return false;
}
catch(std::exception &e)
{
return false;
}
}
/*
Make sure file exists
*/
std::string blockfilename = getBlockFilename(blockpos);
if(fs::PathExists(sectordir+"/"+blockfilename) == false)
return NULL;
/*
Load block and save it to the database
*/
loadBlock(sectordir, blockfilename, sector, true);
return getBlockNoCreateNoEx(blockpos);
}
2010-11-27 00:02:21 +01:00
void ServerMap::PrintInfo(std::ostream &out)
{
out<<"ServerMap: ";
}
#ifndef SERVER
2010-11-27 00:02:21 +01:00
/*
ClientMap
*/
ClientMap::ClientMap(
Client *client,
MapDrawControl &control,
2010-11-27 00:02:21 +01:00
scene::ISceneNode* parent,
scene::ISceneManager* mgr,
s32 id
):
Map(dout_client),
scene::ISceneNode(parent, mgr, id),
m_client(client),
2011-02-23 01:49:57 +01:00
m_control(control),
m_camera_position(0,0,0),
m_camera_direction(0,0,1)
2010-11-27 00:02:21 +01:00
{
2011-02-23 01:49:57 +01:00
m_camera_mutex.Init();
assert(m_camera_mutex.IsInitialized());
2010-11-27 00:02:21 +01:00
m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
BS*1000000,BS*1000000,BS*1000000);
}
ClientMap::~ClientMap()
{
2011-02-05 13:55:16 +01:00
/*JMutexAutoLock lock(mesh_mutex);
2010-11-27 00:02:21 +01:00
if(mesh != NULL)
{
mesh->drop();
mesh = NULL;
2011-02-05 13:55:16 +01:00
}*/
2010-11-27 00:02:21 +01:00
}
MapSector * ClientMap::emergeSector(v2s16 p2d)
{
DSTACK(__FUNCTION_NAME);
// Check that it doesn't exist already
try{
return getSectorNoGenerate(p2d);
}
catch(InvalidPositionException &e)
{
}
// Create a sector
2010-11-27 00:02:21 +01:00
ClientMapSector *sector = new ClientMapSector(this, p2d);
{
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
2010-11-27 00:02:21 +01:00
m_sectors.insert(p2d, sector);
}
return sector;
}
2011-06-25 23:03:58 +02:00
#if 0
2010-11-27 00:02:21 +01:00
void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is)
{
DSTACK(__FUNCTION_NAME);
ClientMapSector *sector = NULL;
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
2010-11-27 00:02:21 +01:00
core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p2d);
if(n != NULL)
{
sector = (ClientMapSector*)n->getValue();
assert(sector->getId() == MAPSECTOR_CLIENT);
}
else
{
sector = new ClientMapSector(this, p2d);
{
//JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out
2010-11-27 00:02:21 +01:00
m_sectors.insert(p2d, sector);
}
}
sector->deSerialize(is);
}
2011-06-25 23:03:58 +02:00
#endif
2010-11-27 00:02:21 +01:00
2010-12-14 12:14:43 +01:00
void ClientMap::OnRegisterSceneNode()
{
if(IsVisible)
{
SceneManager->registerNodeForRendering(this, scene::ESNRP_SOLID);
SceneManager->registerNodeForRendering(this, scene::ESNRP_TRANSPARENT);
}
ISceneNode::OnRegisterSceneNode();
}
void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass)
2010-11-27 00:02:21 +01:00
{
//m_dout<<DTIME<<"Rendering map..."<<std::endl;
DSTACK(__FUNCTION_NAME);
bool is_transparent_pass = pass == scene::ESNRP_TRANSPARENT;
2011-06-18 11:42:17 +02:00
/*
This is called two times per frame, reset on the non-transparent one
*/
if(pass == scene::ESNRP_SOLID)
{
m_last_drawn_sectors.clear();
}
2010-11-27 00:02:21 +01:00
/*
Get time for measuring timeout.
Measuring time is very useful for long delays when the
machine is swapping a lot.
*/
int time1 = time(0);
//u32 daynight_ratio = m_client->getDayNightRatio();
2010-12-19 15:51:45 +01:00
2010-11-27 00:02:21 +01:00
m_camera_mutex.Lock();
v3f camera_position = m_camera_position;
v3f camera_direction = m_camera_direction;
m_camera_mutex.Unlock();
/*
Get all blocks and draw all visible ones
*/
v3s16 cam_pos_nodes(
camera_position.X / BS,
camera_position.Y / BS,
camera_position.Z / BS);
v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1);
2010-11-27 00:02:21 +01:00
v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d;
v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d;
// Take a fair amount as we will be dropping more out later
v3s16 p_blocks_min(
p_nodes_min.X / MAP_BLOCKSIZE - 2,
p_nodes_min.Y / MAP_BLOCKSIZE - 2,
p_nodes_min.Z / MAP_BLOCKSIZE - 2);
2010-11-27 00:02:21 +01:00
v3s16 p_blocks_max(
p_nodes_max.X / MAP_BLOCKSIZE + 1,
p_nodes_max.Y / MAP_BLOCKSIZE + 1,
p_nodes_max.Z / MAP_BLOCKSIZE + 1);
2010-11-27 00:02:21 +01:00
u32 vertex_count = 0;
2010-12-18 16:46:00 +01:00
// For limiting number of mesh updates per frame
u32 mesh_update_count = 0;
u32 blocks_would_have_drawn = 0;
u32 blocks_drawn = 0;
2010-11-27 00:02:21 +01:00
2010-12-19 15:51:45 +01:00
int timecheck_counter = 0;
2010-12-18 16:46:00 +01:00
core::map<v2s16, MapSector*>::Iterator si;
2010-11-27 00:02:21 +01:00
si = m_sectors.getIterator();
for(; si.atEnd() == false; si++)
{
{
timecheck_counter++;
if(timecheck_counter > 50)
{
timecheck_counter = 0;
2010-11-27 00:02:21 +01:00
int time2 = time(0);
if(time2 > time1 + 4)
{
dstream<<"ClientMap::renderMap(): "
"Rendering takes ages, returning."
<<std::endl;
return;
}
}
}
MapSector *sector = si.getNode()->getValue();
v2s16 sp = sector->getPos();
if(m_control.range_all == false)
2010-11-27 00:02:21 +01:00
{
if(sp.X < p_blocks_min.X
|| sp.X > p_blocks_max.X
|| sp.Y < p_blocks_min.Z
|| sp.Y > p_blocks_max.Z)
continue;
}
core::list< MapBlock * > sectorblocks;
sector->getBlocks(sectorblocks);
/*
Draw blocks
*/
2011-06-18 11:42:17 +02:00
u32 sector_blocks_drawn = 0;
2010-11-27 00:02:21 +01:00
core::list< MapBlock * >::Iterator i;
for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
{
MapBlock *block = *i;
/*
Compare block position to camera position, skip
if not seen on display
*/
float range = 100000 * BS;
if(m_control.range_all == false)
range = m_control.wanted_range * BS;
2011-02-04 00:22:07 +01:00
float d = 0.0;
if(isBlockInSight(block->getPos(), camera_position,
2011-02-04 00:22:07 +01:00
camera_direction, range, &d) == false)
{
continue;
}
// Okay, this block will be drawn. Reset usage timer.
block->resetUsageTimer();
// This is ugly (spherical distance limit?)
/*if(m_control.range_all == false &&
d - 0.5*BS*MAP_BLOCKSIZE > range)
continue;*/
#if 1
2010-11-27 00:02:21 +01:00
/*
Update expired mesh (used for day/night change)
It doesn't work exactly like it should now with the
tasked mesh update but whatever.
2010-11-27 00:02:21 +01:00
*/
2010-12-18 16:46:00 +01:00
bool mesh_expired = false;
2010-11-27 00:02:21 +01:00
{
JMutexAutoLock lock(block->mesh_mutex);
2010-12-18 16:46:00 +01:00
mesh_expired = block->getMeshExpired();
// Mesh has not been expired and there is no mesh:
// block has no content
if(block->mesh == NULL && mesh_expired == false)
continue;
}
2010-12-19 15:51:45 +01:00
f32 faraway = BS*50;
//f32 faraway = m_control.wanted_range * BS;
2010-12-18 16:46:00 +01:00
/*
This has to be done with the mesh_mutex unlocked
*/
// Pretty random but this should work somewhat nicely
if(mesh_expired && (
(mesh_update_count < 3
&& (d < faraway || mesh_update_count < 2)
)
||
(m_control.range_all && mesh_update_count < 20)
)
)
/*if(mesh_expired && mesh_update_count < 6
&& (d < faraway || mesh_update_count < 3))*/
2010-12-18 16:46:00 +01:00
{
mesh_update_count++;
// Mesh has been expired: generate new mesh
//block->updateMesh(daynight_ratio);
m_client->addUpdateMeshTask(block->getPos());
2010-12-18 16:46:00 +01:00
2010-12-19 15:51:45 +01:00
mesh_expired = false;
}
#endif
/*
Draw the faces of the block
*/
2010-12-19 15:51:45 +01:00
{
JMutexAutoLock lock(block->mesh_mutex);
scene::SMesh *mesh = block->mesh;
2010-12-18 16:46:00 +01:00
2010-12-19 15:51:45 +01:00
if(mesh == NULL)
2010-11-27 00:02:21 +01:00
continue;
blocks_would_have_drawn++;
if(blocks_drawn >= m_control.wanted_max_blocks
&& m_control.range_all == false
&& d > m_control.wanted_min_range * BS)
continue;
2011-06-18 11:42:17 +02:00
blocks_drawn++;
2011-06-18 11:42:17 +02:00
sector_blocks_drawn++;
2010-11-27 00:02:21 +01:00
2010-12-19 15:51:45 +01:00
u32 c = mesh->getMeshBufferCount();
2010-11-27 00:02:21 +01:00
for(u32 i=0; i<c; i++)
{
2010-12-19 15:51:45 +01:00
scene::IMeshBuffer *buf = mesh->getMeshBuffer(i);
2010-11-27 00:02:21 +01:00
const video::SMaterial& material = buf->getMaterial();
video::IMaterialRenderer* rnd =
driver->getMaterialRenderer(material.MaterialType);
bool transparent = (rnd && rnd->isTransparent());
// Render transparent on transparent pass and likewise.
if(transparent == is_transparent_pass)
{
/*
This *shouldn't* hurt too much because Irrlicht
doesn't change opengl textures if the old
material is set again.
*/
2010-11-27 00:02:21 +01:00
driver->setMaterial(buf->getMaterial());
driver->drawMeshBuffer(buf);
vertex_count += buf->getVertexCount();
}
}
}
} // foreach sectorblocks
2011-06-18 11:42:17 +02:00
if(sector_blocks_drawn != 0)
{
m_last_drawn_sectors[sp] = true;
}
2010-11-27 00:02:21 +01:00
}
m_control.blocks_drawn = blocks_drawn;
m_control.blocks_would_have_drawn = blocks_would_have_drawn;
2010-11-27 00:02:21 +01:00
/*dstream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
<<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
}
bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
core::map<v3s16, MapBlock*> *affected_blocks)
2010-11-27 00:02:21 +01:00
{
bool changed = false;
2010-12-21 17:08:24 +01:00
/*
Add it to all blocks touching it
*/
v3s16 dirs[7] = {
v3s16(0,0,0), // this
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
};
for(u16 i=0; i<7; i++)
{
v3s16 p2 = p + dirs[i];
// Block position of neighbor (or requested) node
v3s16 blockpos = getNodeBlockPos(p2);
MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
if(blockref == NULL)
continue;
// Relative position of requested node
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
if(blockref->setTempMod(relpos, mod))
{
changed = true;
}
2010-12-21 17:08:24 +01:00
}
if(changed && affected_blocks!=NULL)
{
for(u16 i=0; i<7; i++)
{
v3s16 p2 = p + dirs[i];
// Block position of neighbor (or requested) node
v3s16 blockpos = getNodeBlockPos(p2);
MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
if(blockref == NULL)
continue;
affected_blocks->insert(blockpos, blockref);
}
}
return changed;
2010-12-21 01:25:47 +01:00
}
bool ClientMap::clearTempMod(v3s16 p,
core::map<v3s16, MapBlock*> *affected_blocks)
2010-12-21 01:25:47 +01:00
{
bool changed = false;
2010-12-21 17:08:24 +01:00
v3s16 dirs[7] = {
v3s16(0,0,0), // this
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
};
for(u16 i=0; i<7; i++)
{
v3s16 p2 = p + dirs[i];
// Block position of neighbor (or requested) node
v3s16 blockpos = getNodeBlockPos(p2);
MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
if(blockref == NULL)
continue;
// Relative position of requested node
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
if(blockref->clearTempMod(relpos))
{
changed = true;
}
}
if(changed && affected_blocks!=NULL)
{
for(u16 i=0; i<7; i++)
{
v3s16 p2 = p + dirs[i];
// Block position of neighbor (or requested) node
v3s16 blockpos = getNodeBlockPos(p2);
MapBlock * blockref = getBlockNoCreateNoEx(blockpos);
if(blockref == NULL)
continue;
affected_blocks->insert(blockpos, blockref);
}
2010-12-21 17:08:24 +01:00
}
return changed;
2010-11-27 00:02:21 +01:00
}
void ClientMap::expireMeshes(bool only_daynight_diffed)
{
TimeTaker timer("expireMeshes()");
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;
if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
{
continue;
}
{
JMutexAutoLock lock(block->mesh_mutex);
if(block->mesh != NULL)
{
/*block->mesh->drop();
block->mesh = NULL;*/
block->setMeshExpired(true);
}
}
}
}
}
void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
{
assert(mapType() == MAPTYPE_CLIENT);
try{
v3s16 p = blockpos + v3s16(0,0,0);
MapBlock *b = getBlockNoCreate(p);
b->updateMesh(daynight_ratio);
//b->setMeshExpired(true);
}
catch(InvalidPositionException &e){}
// Leading edge
try{
v3s16 p = blockpos + v3s16(-1,0,0);
MapBlock *b = getBlockNoCreate(p);
b->updateMesh(daynight_ratio);
//b->setMeshExpired(true);
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,-1,0);
MapBlock *b = getBlockNoCreate(p);
b->updateMesh(daynight_ratio);
//b->setMeshExpired(true);
}
catch(InvalidPositionException &e){}
try{
v3s16 p = blockpos + v3s16(0,0,-1);
MapBlock *b = getBlockNoCreate(p);
b->updateMesh(daynight_ratio);
//b->setMeshExpired(true);
}
catch(InvalidPositionException &e){}
}
#if 0
/*
Update mesh of block in which the node is, and if the node is at the
leading edge, update the appropriate leading blocks too.
*/
void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio)
{
v3s16 dirs[4] = {
v3s16(0,0,0),
v3s16(-1,0,0),
v3s16(0,-1,0),
v3s16(0,0,-1),
};
v3s16 blockposes[4];
for(u32 i=0; i<4; i++)
{
v3s16 np = nodepos + dirs[i];
blockposes[i] = getNodeBlockPos(np);
// Don't update mesh of block if it has been done already
bool already_updated = false;
for(u32 j=0; j<i; j++)
{
if(blockposes[j] == blockposes[i])
{
already_updated = true;
break;
}
}
if(already_updated)
continue;
// Update mesh
MapBlock *b = getBlockNoCreate(blockposes[i]);
b->updateMesh(daynight_ratio);
}
}
#endif
2010-11-27 00:02:21 +01:00
void ClientMap::PrintInfo(std::ostream &out)
{
out<<"ClientMap: ";
}
#endif // !SERVER
2010-11-27 00:02:21 +01:00
/*
MapVoxelManipulator
*/
MapVoxelManipulator::MapVoxelManipulator(Map *map)
{
m_map = map;
}
MapVoxelManipulator::~MapVoxelManipulator()
{
2010-12-13 20:32:35 +01:00
/*dstream<<"MapVoxelManipulator: blocks: "<<m_loaded_blocks.size()
<<std::endl;*/
}
void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
2010-12-21 17:08:24 +01:00
TimeTaker timer1("emerge", &emerge_time);
// Units of these are MapBlocks
v3s16 p_min = getNodeBlockPos(a.MinEdge);
v3s16 p_max = getNodeBlockPos(a.MaxEdge);
VoxelArea block_area_nodes
(p_min*MAP_BLOCKSIZE, (p_max+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
addArea(block_area_nodes);
for(s32 z=p_min.Z; z<=p_max.Z; z++)
for(s32 y=p_min.Y; y<=p_max.Y; y++)
for(s32 x=p_min.X; x<=p_max.X; x++)
{
v3s16 p(x,y,z);
core::map<v3s16, bool>::Node *n;
n = m_loaded_blocks.find(p);
if(n != NULL)
continue;
bool block_data_inexistent = false;
try
{
2010-12-21 17:08:24 +01:00
TimeTaker timer1("emerge load", &emerge_load_time);
/*dstream<<"Loading block (caller_id="<<caller_id<<")"
<<" ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<" wanted area: ";
a.print(dstream);
dstream<<std::endl;*/
MapBlock *block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
else
block->copyTo(*this);
}
catch(InvalidPositionException &e)
{
block_data_inexistent = true;
}
if(block_data_inexistent)
{
VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
// Fill with VOXELFLAG_INEXISTENT
for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
{
s32 i = m_area.index(a.MinEdge.X,y,z);
memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
}
}
m_loaded_blocks.insert(p, !block_data_inexistent);
}
//dstream<<"emerge done"<<std::endl;
}
/*
SUGG: Add an option to only update eg. water and air nodes.
This will make it interfere less with important stuff if
run on background.
*/
void MapVoxelManipulator::blitBack
(core::map<v3s16, MapBlock*> & modified_blocks)
{
if(m_area.getExtent() == v3s16(0,0,0))
return;
2010-12-21 17:08:24 +01:00
//TimeTaker timer1("blitBack");
2011-01-24 15:36:58 +01:00
/*dstream<<"blitBack(): m_loaded_blocks.size()="
<<m_loaded_blocks.size()<<std::endl;*/
/*
Initialize block cache
*/
v3s16 blockpos_last;
MapBlock *block = NULL;
bool block_checked_in_modified = false;
for(s32 z=m_area.MinEdge.Z; z<=m_area.MaxEdge.Z; z++)
for(s32 y=m_area.MinEdge.Y; y<=m_area.MaxEdge.Y; y++)
for(s32 x=m_area.MinEdge.X; x<=m_area.MaxEdge.X; x++)
{
v3s16 p(x,y,z);
u8 f = m_flags[m_area.index(p)];
if(f & (VOXELFLAG_NOT_LOADED|VOXELFLAG_INEXISTENT))
continue;
MapNode &n = m_data[m_area.index(p)];
v3s16 blockpos = getNodeBlockPos(p);
try
{
// Get block
if(block == NULL || blockpos != blockpos_last){
block = m_map->getBlockNoCreate(blockpos);
blockpos_last = blockpos;
block_checked_in_modified = false;
}
// Calculate relative position in block
v3s16 relpos = p - blockpos * MAP_BLOCKSIZE;
// Don't continue if nothing has changed here
if(block->getNode(relpos) == n)
continue;
//m_map->setNode(m_area.MinEdge + p, n);
block->setNode(relpos, n);
/*
Make sure block is in modified_blocks
*/
if(block_checked_in_modified == false)
{
modified_blocks[blockpos] = block;
block_checked_in_modified = true;
}
}
catch(InvalidPositionException &e)
{
}
}
}
2011-01-24 15:36:58 +01:00
ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
2011-04-11 10:36:13 +02:00
MapVoxelManipulator(map),
m_create_area(false)
2011-01-24 15:36:58 +01:00
{
}
ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
{
}
void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
// Just create the area so that it can be pointed to
2011-01-24 15:36:58 +01:00
VoxelManipulator::emerge(a, caller_id);
}
void ManualMapVoxelManipulator::initialEmerge(
v3s16 blockpos_min, v3s16 blockpos_max)
{
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));
u32 size_MB = block_area_nodes.getVolume()*4/1000000;
if(size_MB >= 1)
{
dstream<<"initialEmerge: area: ";
block_area_nodes.print(dstream);
dstream<<" ("<<size_MB<<"MB)";
dstream<<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++)
{
v3s16 p(x,y,z);
core::map<v3s16, bool>::Node *n;
n = m_loaded_blocks.find(p);
if(n != NULL)
continue;
bool block_data_inexistent = false;
try
{
TimeTaker timer1("emerge load", &emerge_load_time);
MapBlock *block = m_map->getBlockNoCreate(p);
if(block->isDummy())
block_data_inexistent = true;
else
block->copyTo(*this);
}
catch(InvalidPositionException &e)
{
block_data_inexistent = true;
}
if(block_data_inexistent)
{
/*
Mark area inexistent
*/
2011-01-24 15:36:58 +01:00
VoxelArea a(p*MAP_BLOCKSIZE, (p+1)*MAP_BLOCKSIZE-v3s16(1,1,1));
// Fill with VOXELFLAG_INEXISTENT
for(s32 z=a.MinEdge.Z; z<=a.MaxEdge.Z; z++)
for(s32 y=a.MinEdge.Y; y<=a.MaxEdge.Y; y++)
{
s32 i = m_area.index(a.MinEdge.X,y,z);
memset(&m_flags[i], VOXELFLAG_INEXISTENT, MAP_BLOCKSIZE);
}
}
m_loaded_blocks.insert(p, !block_data_inexistent);
}
}
void ManualMapVoxelManipulator::blitBackAll(
core::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++)
{
v3s16 p = i.getNode()->getKey();
bool existed = i.getNode()->getValue();
if(existed == false)
{
// The Great Bug was found using this
/*dstream<<"ManualMapVoxelManipulator::blitBackAll: "
<<"Inexistent ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
<<std::endl;*/
continue;
}
MapBlock *block = m_map->getBlockNoCreateNoEx(p);
if(block == NULL)
{
dstream<<"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);
2011-01-24 15:36:58 +01:00
}
}
//END