#include "utility.h"
#include "voxel.h"
#include "porting.h"
-
-#if 0
-MapBlockPointerCache::MapBlockPointerCache(Map *map)
-{
- m_map = map;
- m_map->m_blockcachelock.cacheCreated();
-
- m_from_cache_count = 0;
- m_from_map_count = 0;
-}
-
-MapBlockPointerCache::~MapBlockPointerCache()
-{
- m_map->m_blockcachelock.cacheRemoved();
-
- /*dstream<<"MapBlockPointerCache:"
- <<" from_cache_count="<<m_from_cache_count
- <<" from_map_count="<<m_from_map_count
- <<std::endl;*/
-}
-
-MapBlock * MapBlockPointerCache::getBlockNoCreate(v3s16 p)
-{
- core::map<v3s16, MapBlock*>::Node *n = NULL;
- n = m_blocks.find(p);
- if(n != NULL)
- {
- m_from_cache_count++;
- return n->getValue();
- }
-
- m_from_map_count++;
-
- // Throws InvalidPositionException if not found
- MapBlock *b = m_map->getBlockNoCreate(p);
- m_blocks[p] = b;
- return b;
-}
-#endif
+#include "mineral.h"
+#include "noise.h"
/*
Map
m_dout(dout),
m_camera_position(0,0,0),
m_camera_direction(0,0,1),
- m_sector_cache(NULL),
- m_hwrapper(this),
- drawoffset(0,0,0)
+ m_sector_cache(NULL)
{
m_sector_mutex.Init();
m_camera_mutex.Init();
}
}
-MapSector * Map::getSectorNoGenerate(v2s16 p)
+MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
{
- JMutexAutoLock lock(m_sector_mutex);
-
if(m_sector_cache != NULL && p == m_sector_cache_p){
MapSector * sector = m_sector_cache;
// Reset inactivity timer
}
core::map<v2s16, MapSector*>::Node *n = m_sectors.find(p);
- // If sector doesn't exist, throw an exception
+
if(n == NULL)
- {
- throw InvalidPositionException();
- }
+ return NULL;
MapSector *sector = n->getValue();
m_sector_cache_p = p;
m_sector_cache = sector;
- //MapSector * ref(sector);
-
// Reset inactivity timer
sector->usage_timer = 0.0;
return sector;
}
+MapSector * Map::getSectorNoGenerateNoEx(v2s16 p)
+{
+ JMutexAutoLock lock(m_sector_mutex);
+
+ return getSectorNoGenerateNoExNoLock(p);
+}
+
+MapSector * Map::getSectorNoGenerate(v2s16 p)
+{
+ MapSector *sector = getSectorNoGenerateNoEx(p);
+ if(sector == NULL)
+ throw InvalidPositionException();
+
+ return sector;
+}
+
MapBlock * Map::getBlockNoCreate(v3s16 p3d)
{
v2s16 p2d(p3d.X, p3d.Z);
}
}
+/*MapBlock * Map::getBlockCreate(v3s16 p3d)
+{
+ v2s16 p2d(p3d.X, p3d.Z);
+ MapSector * sector = getSectorCreate(p2d);
+ assert(sector);
+ MapBlock *block = sector->getBlockNoCreate(p3d.Y);
+ if(block)
+ return block;
+ block = sector->createBlankBlock(p3d.Y);
+ return block;
+}*/
+
f32 Map::getGroundHeight(v2s16 p, bool generate)
{
try{
Starting point gets sunlight.
Returns the lowest y value of where the sunlight went.
+
+ Mud is turned into grass in where the sunlight stops.
*/
s16 Map::propagateSunlight(v3s16 start,
core::map<v3s16, MapBlock*> & modified_blocks)
modified_blocks.insert(blockpos, block);
}
- else{
+ else
+ {
+ // Turn mud into grass
+ if(n.d == CONTENT_MUD)
+ {
+ n.d = CONTENT_GRASS;
+ block->setNode(relpos, n);
+ modified_blocks.insert(blockpos, block);
+ }
+
+ // Sunlight goes no further
break;
}
}
core::map<v3s16, MapBlock*> & modified_blocks)
{
/*m_dout<<DTIME<<"Map::updateLighting(): "
- <<a_blocks.getSize()<<" blocks... ";*/
+ <<a_blocks.size()<<" blocks."<<std::endl;*/
+
+ //TimeTaker timer("updateLighting");
// For debugging
- bool debug=false;
- u32 count_was = modified_blocks.size();
+ //bool debug=true;
+ //u32 count_was = modified_blocks.size();
+
+ core::map<v3s16, MapBlock*> blocks_to_update;
core::map<v3s16, bool> light_sources;
v3s16 pos = block->getPos();
modified_blocks.insert(pos, block);
+ blocks_to_update.insert(pos, block);
+
/*
Clear all light from block
*/
}
else if(bank == LIGHTBANK_NIGHT)
{
+ // For night lighting, sunlight is not propagated
break;
}
else
{
+ // Invalid lighting bank
assert(0);
}
<<pos.X<<","<<pos.Y<<","<<pos.Z<<") not valid"
<<std::endl;*/
- // Else get the block below and loop to it
+ // Bottom sunlight is not valid; get the block and loop to it
pos.Y--;
try{
}
}
-
+
+#if 0
{
- //TimeTaker timer("unspreadLight");
+ TimeTaker timer("unspreadLight");
unspreadLight(bank, unlight_from, light_sources, modified_blocks);
}
dstream<<"unspreadLight modified "<<diff<<std::endl;
}
- // TODO: Spread light from propagated sunlight?
- // Yes, add it to light_sources... somehow.
- // It has to be added at somewhere above, in the loop.
- // TODO
- // NOTE: This actually works fine without doing so
- // - Find out why it works
-
{
- //TimeTaker timer("spreadLight");
+ TimeTaker timer("spreadLight");
spreadLight(bank, light_sources, modified_blocks);
}
count_was = modified_blocks.size();
dstream<<"spreadLight modified "<<diff<<std::endl;
}
+#endif
+
+ {
+ //MapVoxelManipulator vmanip(this);
+
+ // Make a manual voxel manipulator and load all the blocks
+ // that touch the requested blocks
+ ManualMapVoxelManipulator vmanip(this);
+ 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();
+
+ // Add all surrounding blocks
+ 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);
+ }
+
+ {
+ //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;*/
+ }
//m_dout<<"Done ("<<getTimestamp()<<")"<<std::endl;
}
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);
+ if(content_liquid(n2.d))
+ {
+ m_transforming_liquid.push_back(p2);
+ }
+
+ }catch(InvalidPositionException &e)
+ {
+ }
+ }
}
/*
MapBlock *block = i.getNode()->getValue();
block->updateDayNightDiff();
}
+
+ /*
+ Add neighboring liquid nodes to transform queue.
+ */
+ 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
+ };
+ for(u16 i=0; i<6; i++)
+ {
+ try
+ {
+
+ v3s16 p2 = p + dirs[i];
+
+ MapNode n2 = getNode(p2);
+ if(content_liquid(n2.d))
+ {
+ m_transforming_liquid.push_back(p2);
+ }
+
+ }catch(InvalidPositionException &e)
+ {
+ }
+ }
}
#ifndef SERVER
This disables the existence of caches while locked
*/
- SharedPtr<JMutexAutoLock> cachelock(m_blockcachelock.waitCaches());
+ //SharedPtr<JMutexAutoLock> cachelock(m_blockcachelock.waitCaches());
core::list<v2s16>::Iterator j;
for(j=list.begin(); j!=list.end(); j++)
out<<"Map: ";
}
-/*
- ServerMap
-*/
+#define WATER_DROP_BOOST 4
-ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
- Map(dout_server),
- m_heightmap(NULL)
+void Map::transformLiquids(core::map<v3s16, MapBlock*> & modified_blocks)
{
- m_savedir = savedir;
- m_map_saving_enabled = false;
-
- 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
- {
- // Load master heightmap
- loadMasterHeightmap();
-
- // Load sector (0,0) and throw and exception on fail
- if(loadSectorFull(v2s16(0,0)) == false)
- throw LoadError("Failed to load sector (0,0)");
+ DSTACK(__FUNCTION_NAME);
+ //TimeTaker timer("transformLiquids()");
- dstream<<DTIME<<"Server: Successfully loaded master "
- "heightmap and sector (0,0) from "<<savedir<<
- ", assuming valid save directory."
- <<std::endl;
+ u32 loopcount = 0;
+ u32 initial_size = m_transforming_liquid.size();
+
+ /*if(initial_size != 0)
+ dstream<<"transformLiquids(): initial_size="<<initial_size<<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)
+ while(m_transforming_liquid.size() != 0)
{
- dstream<<DTIME<<"Server: Failed to load map from "<<savedir
- <<", exception: "<<e.what()<<std::endl;
- dstream<<DTIME<<"Please remove the map or fix it."<<std::endl;
- dstream<<DTIME<<"WARNING: Map saving will be disabled."<<std::endl;
- }
+ /*
+ Get a queued transforming liquid node
+ */
+ v3s16 p0 = m_transforming_liquid.pop_front();
- dstream<<DTIME<<"Initializing new map."<<std::endl;
-
- // Create master heightmap
- ValueGenerator *maxgen =
- ValueGenerator::deSerialize(hmp.randmax);
- ValueGenerator *factorgen =
- ValueGenerator::deSerialize(hmp.randfactor);
- ValueGenerator *basegen =
- ValueGenerator::deSerialize(hmp.base);
- m_heightmap = new UnlimitedHeightmap
- (hmp.blocksize, maxgen, factorgen, basegen);
-
- // Set map parameters
- m_params = mp;
-
- // Create zero sector
- emergeSector(v2s16(0,0));
+ MapNode n0 = getNode(p0);
+
+ // Don't deal with non-liquids
+ if(content_liquid(n0.d) == false)
+ continue;
- // Initially write whole map
- save(false);
-}
+ bool is_source = !content_flowing_liquid(n0.d);
+
+ u8 liquid_level = 8;
+ if(is_source == false)
+ liquid_level = n0.param2 & 0x0f;
+
+ // Turn possible source into non-source
+ u8 nonsource_c = make_liquid_flowing(n0.d);
-ServerMap::~ServerMap()
-{
- try
- {
- if(m_map_saving_enabled)
- {
- //save(false);
- // Save only changed parts
- save(true);
- dstream<<DTIME<<"Server: saved map to "<<m_savedir<<std::endl;
- }
- else
+ /*
+ If not source, check that some node flows into this one
+ and what is the level of liquid in this one
+ */
+ if(is_source == false)
{
- 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;
- }
-
- if(m_heightmap != NULL)
- delete m_heightmap;
-}
+ s8 new_liquid_level_max = -1;
-MapSector * ServerMap::emergeSector(v2s16 p2d)
-{
- DSTACK("%s: p2d=(%d,%d)",
- __FUNCTION_NAME,
- p2d.X, p2d.Y);
- // Check that it doesn't exist already
- try{
- return getSectorNoGenerate(p2d);
- }
- catch(InvalidPositionException &e)
- {
- }
-
- /*
- Try to load the sector from disk.
- */
- if(loadSectorFull(p2d) == true)
- {
- return getSectorNoGenerate(p2d);
- }
+ v3s16 dirs_from[5] = {
+ v3s16(0,1,0), // top
+ v3s16(0,0,1), // back
+ v3s16(1,0,0), // right
+ v3s16(0,0,-1), // front
+ v3s16(-1,0,0), // left
+ };
+ for(u16 i=0; i<5; i++)
+ {
+ try
+ {
- /*
- If there is no master heightmap, throw.
- */
- if(m_heightmap == NULL)
- {
- throw InvalidPositionException("emergeSector(): no heightmap");
- }
+ bool from_top = (i==0);
- /*
- Do not generate 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("emergeSector(): pos. over limit");
+ v3s16 p2 = p0 + dirs_from[i];
+ MapNode n2 = getNode(p2);
- /*
- Generate sector and heightmaps
- */
-
- // Number of heightmaps in sector in each direction
- u16 hm_split = SECTOR_HEIGHTMAP_SPLIT;
+ if(content_liquid(n2.d))
+ {
+ u8 n2_nonsource_c = make_liquid_flowing(n2.d);
+ // Check that the liquids are the same type
+ if(n2_nonsource_c != nonsource_c)
+ {
+ dstream<<"WARNING: Not handling: different liquids"
+ " collide"<<std::endl;
+ continue;
+ }
+ bool n2_is_source = !content_flowing_liquid(n2.d);
+ s8 n2_liquid_level = 8;
+ if(n2_is_source == false)
+ n2_liquid_level = n2.param2 & 0x07;
+
+ s8 new_liquid_level = -1;
+ if(from_top)
+ {
+ //new_liquid_level = 7;
+ if(n2_liquid_level >= 7 - WATER_DROP_BOOST)
+ new_liquid_level = 7;
+ else
+ new_liquid_level = n2_liquid_level + WATER_DROP_BOOST;
+ }
+ else if(n2_liquid_level > 0)
+ {
+ new_liquid_level = n2_liquid_level - 1;
+ }
- // Heightmap side width
- s16 hm_d = MAP_BLOCKSIZE / hm_split;
+ if(new_liquid_level > new_liquid_level_max)
+ new_liquid_level_max = new_liquid_level;
+ }
+
+ }catch(InvalidPositionException &e)
+ {
+ }
+ } //for
+
+ /*
+ If liquid level should be something else, update it and
+ add all the neighboring water nodes to the transform queue.
+ */
+ if(new_liquid_level_max != liquid_level)
+ {
+ if(new_liquid_level_max == -1)
+ {
+ // Remove water alltoghether
+ n0.d = CONTENT_AIR;
+ n0.param2 = 0;
+ setNode(p0, n0);
+ }
+ else
+ {
+ n0.param2 = new_liquid_level_max;
+ setNode(p0, n0);
+ }
+
+ // Block has been modified
+ {
+ v3s16 blockpos = getNodeBlockPos(p0);
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block != NULL)
+ modified_blocks.insert(blockpos, block);
+ }
+
+ /*
+ Add neighboring non-source liquid nodes to transform queue.
+ */
+ 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
+ };
+ for(u16 i=0; i<6; i++)
+ {
+ try
+ {
+
+ v3s16 p2 = p0 + dirs[i];
+
+ MapNode n2 = getNode(p2);
+ if(content_flowing_liquid(n2.d))
+ {
+ m_transforming_liquid.push_back(p2);
+ }
+
+ }catch(InvalidPositionException &e)
+ {
+ }
+ }
+ }
+ }
+
+ // Get a new one from queue if the node has turned into non-water
+ if(content_liquid(n0.d) == false)
+ continue;
+
+ /*
+ Flow water from this node
+ */
+ v3s16 dirs_to[5] = {
+ v3s16(0,-1,0), // bottom
+ v3s16(0,0,1), // back
+ v3s16(1,0,0), // right
+ v3s16(0,0,-1), // front
+ v3s16(-1,0,0), // left
+ };
+ for(u16 i=0; i<5; i++)
+ {
+ try
+ {
+
+ bool to_bottom = (i == 0);
+
+ // If liquid is at lowest possible height, it's not going
+ // anywhere except down
+ if(liquid_level == 0 && to_bottom == false)
+ continue;
+
+ u8 liquid_next_level = 0;
+ // If going to bottom
+ if(to_bottom)
+ {
+ //liquid_next_level = 7;
+ if(liquid_level >= 7 - WATER_DROP_BOOST)
+ liquid_next_level = 7;
+ else
+ liquid_next_level = liquid_level + WATER_DROP_BOOST;
+ }
+ else
+ liquid_next_level = liquid_level - 1;
+
+ bool n2_changed = false;
+ bool flowed = false;
+
+ v3s16 p2 = p0 + dirs_to[i];
+
+ MapNode n2 = getNode(p2);
+ //dstream<<"[1] n2.param="<<(int)n2.param<<std::endl;
+
+ if(content_liquid(n2.d))
+ {
+ u8 n2_nonsource_c = make_liquid_flowing(n2.d);
+ // Check that the liquids are the same type
+ if(n2_nonsource_c != nonsource_c)
+ {
+ dstream<<"WARNING: Not handling: different liquids"
+ " collide"<<std::endl;
+ continue;
+ }
+ bool n2_is_source = !content_flowing_liquid(n2.d);
+ u8 n2_liquid_level = 8;
+ if(n2_is_source == false)
+ n2_liquid_level = n2.param2 & 0x07;
+
+ if(to_bottom)
+ {
+ flowed = true;
+ }
+
+ if(n2_is_source)
+ {
+ // Just flow into the source, nothing changes.
+ // n2_changed is not set because destination didn't change
+ flowed = true;
+ }
+ else
+ {
+ if(liquid_next_level > liquid_level)
+ {
+ n2.param2 = liquid_next_level;
+ setNode(p2, n2);
+
+ n2_changed = true;
+ flowed = true;
+ }
+ }
+ }
+ else if(n2.d == CONTENT_AIR)
+ {
+ n2.d = nonsource_c;
+ n2.param2 = liquid_next_level;
+ setNode(p2, n2);
+
+ n2_changed = true;
+ flowed = true;
+ }
+
+ //dstream<<"[2] n2.param="<<(int)n2.param<<std::endl;
+
+ if(n2_changed)
+ {
+ m_transforming_liquid.push_back(p2);
+
+ v3s16 blockpos = getNodeBlockPos(p2);
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block != NULL)
+ modified_blocks.insert(blockpos, block);
+ }
+
+ // If n2_changed to bottom, don't flow anywhere else
+ if(to_bottom && flowed && !is_source)
+ break;
+
+ }catch(InvalidPositionException &e)
+ {
+ }
+ }
+
+ loopcount++;
+ //if(loopcount >= 100000)
+ if(loopcount >= initial_size * 1)
+ break;
+ }
+ //dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
+}
+
+/*
+ ServerMap
+*/
+
+ServerMap::ServerMap(std::string savedir):
+ Map(dout_server),
+ m_seed(0)
+{
+
+ //m_chunksize = 64;
+ //m_chunksize = 16; // Too slow
+ m_chunksize = 8; // Takes a few seconds
+ //m_chunksize = 4;
+ //m_chunksize = 2;
+
+ // TODO: Save to and load from a file
+ m_seed = (((u64)(myrand()%0xffff)<<0)
+ + ((u64)(myrand()%0xffff)<<16)
+ + ((u64)(myrand()%0xffff)<<32)
+ + ((u64)(myrand()%0xffff)<<48));
+
+ /*
+ Experimental and debug stuff
+ */
+
+ {
+ }
+
+ /*
+ Try to load map; if not found, create a new one.
+ */
+
+ m_savedir = savedir;
+ m_map_saving_enabled = false;
+
+ 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
+ {
+ // Load map metadata (seed, chunksize)
+ loadMapMeta();
+
+ // Load chunk metadata
+ loadChunkMeta();
+
+ /*// Load sector (0,0) and throw and exception on fail
+ if(loadSectorFull(v2s16(0,0)) == false)
+ throw LoadError("Failed to load sector (0,0)");*/
+
+ /*dstream<<DTIME<<"Server: Successfully loaded chunk "
+ "metadata and sector (0,0) from "<<savedir<<
+ ", assuming valid save directory."
+ <<std::endl;*/
+
+ dstream<<DTIME<<"INFO: Server: Successfully loaded map "
+ <<"and chunk metadata from "<<savedir
+ <<", assuming valid save directory."
+ <<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)
+ {
+ dstream<<DTIME<<"WARNING: Server: Failed to load map from "<<savedir
+ <<", exception: "<<e.what()<<std::endl;
+ dstream<<"Please remove the map or fix it."<<std::endl;
+ dstream<<"WARNING: Map saving will be disabled."<<std::endl;
+ }
+
+ dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
+
+ // Create zero sector
+ emergeSector(v2s16(0,0));
+
+ // Initially write whole map
+ save(false);
+}
+
+ServerMap::~ServerMap()
+{
+ try
+ {
+ if(m_map_saving_enabled)
+ {
+ //save(false);
+ // 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;
+ }
+
+ /*
+ Free all MapChunks
+ */
+ core::map<v2s16, MapChunk*>::Iterator i = m_chunks.getIterator();
+ for(; i.atEnd() == false; i++)
+ {
+ MapChunk *chunk = i.getNode()->getValue();
+ delete chunk;
+ }
+}
+
+/*
+ Some helper functions for the map generator
+*/
+
+s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d)
+{
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_nodes_max = vmanip.m_area.MaxEdge.Y;
+ s16 y_nodes_min = vmanip.m_area.MinEdge.Y;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+ s16 y;
+ for(y=y_nodes_max; y>=y_nodes_min; y--)
+ {
+ MapNode &n = vmanip.m_data[i];
+ if(content_walkable(n.d))
+ break;
+
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ if(y >= y_nodes_min)
+ return y;
+ else
+ return y_nodes_min;
+}
+
+s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d)
+{
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_nodes_max = vmanip.m_area.MaxEdge.Y;
+ s16 y_nodes_min = vmanip.m_area.MinEdge.Y;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+ s16 y;
+ for(y=y_nodes_max; y>=y_nodes_min; y--)
+ {
+ MapNode &n = vmanip.m_data[i];
+ if(content_walkable(n.d)
+ && n.d != CONTENT_TREE
+ && n.d != CONTENT_LEAVES)
+ break;
+
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ if(y >= y_nodes_min)
+ return y;
+ else
+ return y_nodes_min;
+}
+
+void make_tree(VoxelManipulator &vmanip, v3s16 p0)
+{
+ MapNode treenode(CONTENT_TREE);
+ MapNode leavesnode(CONTENT_LEAVES);
+
+ s16 trunk_h = myrand_range(3, 6);
+ v3s16 p1 = p0;
+ for(s16 ii=0; ii<trunk_h; ii++)
+ {
+ if(vmanip.m_area.contains(p1))
+ vmanip.m_data[vmanip.m_area.index(p1)] = treenode;
+ p1.Y++;
+ }
+
+ // p1 is now the last piece of the trunk
+ p1.Y -= 1;
+
+ VoxelArea leaves_a(v3s16(-2,-2,-2), v3s16(2,2,2));
+ //SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
+ Buffer<u8> leaves_d(leaves_a.getVolume());
+ for(s32 i=0; i<leaves_a.getVolume(); i++)
+ leaves_d[i] = 0;
+
+ // Force leaves at near the end of the trunk
+ {
+ s16 d = 1;
+ for(s16 z=-d; z<=d; z++)
+ for(s16 y=-d; y<=d; y++)
+ for(s16 x=-d; x<=d; x++)
+ {
+ leaves_d[leaves_a.index(v3s16(x,y,z))] = 1;
+ }
+ }
+
+ // Add leaves randomly
+ for(u32 iii=0; iii<7; iii++)
+ {
+ s16 d = 1;
+
+ v3s16 p(
+ myrand_range(leaves_a.MinEdge.X, leaves_a.MaxEdge.X-d),
+ myrand_range(leaves_a.MinEdge.Y, leaves_a.MaxEdge.Y-d),
+ myrand_range(leaves_a.MinEdge.Z, leaves_a.MaxEdge.Z-d)
+ );
+
+ for(s16 z=0; z<=d; z++)
+ for(s16 y=0; y<=d; y++)
+ for(s16 x=0; x<=d; x++)
+ {
+ leaves_d[leaves_a.index(p+v3s16(x,y,z))] = 1;
+ }
+ }
+
+ // Blit leaves to vmanip
+ for(s16 z=leaves_a.MinEdge.Z; z<=leaves_a.MaxEdge.Z; z++)
+ for(s16 y=leaves_a.MinEdge.Y; y<=leaves_a.MaxEdge.Y; y++)
+ for(s16 x=leaves_a.MinEdge.X; x<=leaves_a.MaxEdge.X; x++)
+ {
+ v3s16 p(x,y,z);
+ p += p1;
+ if(vmanip.m_area.contains(p) == false)
+ continue;
+ u32 vi = vmanip.m_area.index(p);
+ if(vmanip.m_data[vi].d != CONTENT_AIR)
+ continue;
+ u32 i = leaves_a.index(x,y,z);
+ if(leaves_d[i] == 1)
+ vmanip.m_data[vi] = leavesnode;
+ }
+}
+
+/*
+ Noise functions. Make sure seed is mangled differently in each one.
+*/
+
+// Amount of trees per area in nodes
+double tree_amount_2d(u64 seed, v2s16 p)
+{
+ double noise = noise2d_perlin(
+ 0.5+(float)p.X/250, 0.5+(float)p.Y/250,
+ seed+2, 5, 0.66);
+ double zeroval = -0.3;
+ if(noise < zeroval)
+ return 0;
+ else
+ return 0.04 * (noise-zeroval) / (1.0-zeroval);
+}
+
+/*double base_rock_level_2d(u64 seed, v2s16 p)
+{
+ return WATER_LEVEL - 6.0 + 25. * noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ seed, 6, 0.6);
+}*/
+
+/*double highlands_level_2d(u64 seed, v2s16 p)
+{
+ double a = noise2d_perlin(
+ 0.5+(float)p.X/1000., 0.5+(float)p.Y/1000.,
+ seed-359, 6, 0.65);
+ if(a > 0.0)
+ //if(1)
+ {
+ return WATER_LEVEL + 25;
+ return WATER_LEVEL + 55. * noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ seed+85039, 6, 0.69);
+ }
+ else
+ return -100000;
+}*/
+
+double base_rock_level_2d(u64 seed, v2s16 p)
+{
+ // The base ground level
+ double base = (double)WATER_LEVEL - 4.0 + 25. * noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ (seed>>32)+654879876, 6, 0.6);
+
+ /*// A bit hillier one
+ double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ (seed>>27)+90340, 6, 0.69);
+ if(base2 > base)
+ base = base2;*/
+#if 1
+ // Higher ground level
+ double higher = (double)WATER_LEVEL + 25. + 45. * noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed+85039, 5, 0.69);
+ //higher = 30; // For debugging
+
+ // Limit higher to at least base
+ if(higher < base)
+ higher = base;
+
+ // Steepness factor of cliffs
+ double b = 1.0 + 1.0 * noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed-932, 7, 0.7);
+ b = rangelim(b, 0.0, 1000.0);
+ b = pow(b, 5);
+ b *= 7;
+ b = rangelim(b, 3.0, 1000.0);
+ //dstream<<"b="<<b<<std::endl;
+ //double b = 20;
+
+ // Offset to more low
+ double a_off = -0.2;
+ // High/low selector
+ /*double a = 0.5 + b * (a_off + noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ seed-359, 6, 0.7));*/
+ double a = (double)0.5 + b * (a_off + noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed-359, 5, 0.60));
+ // Limit
+ a = rangelim(a, 0.0, 1.0);
+
+ //dstream<<"a="<<a<<std::endl;
+
+ double h = base*(1.0-a) + higher*a;
+#else
+ double h = base;
+#endif
+ return h;
+}
+
+#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1
+
+/*
+ This is the main map generation method
+*/
+
+MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos,
+ core::map<v3s16, MapBlock*> &changed_blocks,
+ bool force)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ /*
+ Don't generate if already fully generated
+ */
+ if(force == false)
+ {
+ MapChunk *chunk = getChunk(chunkpos);
+ if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY)
+ {
+ dstream<<"generateChunkRaw(): Chunk "
+ <<"("<<chunkpos.X<<","<<chunkpos.Y<<")"
+ <<" already generated"<<std::endl;
+ return chunk;
+ }
+ }
+
+ dstream<<"generateChunkRaw(): Generating chunk "
+ <<"("<<chunkpos.X<<","<<chunkpos.Y<<")"
+ <<std::endl;
+
+ TimeTaker timer("generateChunkRaw()");
+
+ // The distance how far into the neighbors the generator is allowed to go.
+ s16 max_spread_amount_sectors = 2;
+ assert(max_spread_amount_sectors <= m_chunksize);
+ s16 max_spread_amount = max_spread_amount_sectors * MAP_BLOCKSIZE;
+
+ // Minimum amount of space left on sides for mud to fall in
+ //s16 min_mud_fall_space = 2;
+
+ // Maximum diameter of stone obstacles in X and Z
+ /*s16 stone_obstacle_max_size = (max_spread_amount-min_mud_fall_space)*2;
+ assert(stone_obstacle_max_size/2 <= max_spread_amount-min_mud_fall_space);*/
+
+ s16 y_blocks_min = -4;
+ s16 y_blocks_max = 3;
+ s16 h_blocks = y_blocks_max - y_blocks_min + 1;
+ s16 y_nodes_min = y_blocks_min * MAP_BLOCKSIZE;
+ s16 y_nodes_max = y_blocks_max * MAP_BLOCKSIZE + MAP_BLOCKSIZE - 1;
+
+ v2s16 sectorpos_base = chunk_to_sector(chunkpos);
+ s16 sectorpos_base_size = m_chunksize;
+
+ /*v2s16 sectorpos_bigbase = chunk_to_sector(chunkpos - v2s16(1,1));
+ s16 sectorpos_bigbase_size = m_chunksize * 3;*/
+ v2s16 sectorpos_bigbase =
+ sectorpos_base - v2s16(1,1) * max_spread_amount_sectors;
+ s16 sectorpos_bigbase_size =
+ sectorpos_base_size + 2 * max_spread_amount_sectors;
+
+ v3s16 bigarea_blocks_min(
+ sectorpos_bigbase.X,
+ y_blocks_min,
+ sectorpos_bigbase.Y
+ );
+
+ v3s16 bigarea_blocks_max(
+ sectorpos_bigbase.X + sectorpos_bigbase_size - 1,
+ y_blocks_max,
+ sectorpos_bigbase.Y + sectorpos_bigbase_size - 1
+ );
+
+ // Relative values to control amount of stuff in one chunk
+ /*u32 relative_area = (u32)sectorpos_base_size*MAP_BLOCKSIZE
+ *(u32)sectorpos_base_size*MAP_BLOCKSIZE;*/
+ u32 relative_volume = (u32)sectorpos_base_size*MAP_BLOCKSIZE
+ *(u32)sectorpos_base_size*MAP_BLOCKSIZE
+ *(u32)h_blocks*MAP_BLOCKSIZE;
+
+ /*
+ The limiting edges of the lighting update, inclusive.
+ */
+ s16 lighting_min_d = 0-max_spread_amount;
+ s16 lighting_max_d = sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+
+ /*
+ Create the whole area of this and the neighboring chunks
+ */
+ {
+ TimeTaker timer("generateChunkRaw() create area");
+
+ for(s16 x=0; x<sectorpos_bigbase_size; x++)
+ for(s16 z=0; z<sectorpos_bigbase_size; z++)
+ {
+ v2s16 sectorpos = sectorpos_bigbase + v2s16(x,z);
+ ServerMapSector *sector = createSector(sectorpos);
+ assert(sector);
+
+ for(s16 y=y_blocks_min; y<=y_blocks_max; y++)
+ {
+ v3s16 blockpos(sectorpos.X, y, sectorpos.Y);
+ MapBlock *block = createBlock(blockpos);
+
+ // Lighting won't be calculated
+ //block->setLightingExpired(true);
+ // Lighting will be calculated
+ block->setLightingExpired(false);
+
+ /*
+ Block gets sunlight if this is true.
+
+ This should be set to true when the top side of a block
+ is completely exposed to the sky.
+
+ Actually this doesn't matter now because the
+ initial lighting is done here.
+ */
+ block->setIsUnderground(y != y_blocks_max);
+ }
+ }
+ }
+
+ /*
+ Now we have a big empty area.
+
+ Make a ManualMapVoxelManipulator that contains this and the
+ neighboring chunks
+ */
+
+ ManualMapVoxelManipulator vmanip(this);
+ // Add the area we just generated
+ {
+ TimeTaker timer("generateChunkRaw() initialEmerge");
+ vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max);
+ }
+
+ // Clear all flags
+ vmanip.clearFlag(0xff);
+
+ TimeTaker timer_generate("generateChunkRaw() generate");
+
+ // Maximum height of the stone surface and obstacles.
+ // This is used to disable dungeon generation from going too high.
+ s16 stone_surface_max_y = 0;
+
+ /*
+ Generate general ground level to full area
+ */
+
+ {
+ // 22ms @cs=8
+ //TimeTaker timer1("ground level");
+
+ for(s16 x=0; x<sectorpos_bigbase_size*MAP_BLOCKSIZE; x++)
+ for(s16 z=0; z<sectorpos_bigbase_size*MAP_BLOCKSIZE; z++)
+ {
+ // Node position
+ v2s16 p2d = sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z);
+
+ /*
+ Skip of already generated
+ */
+ {
+ v3s16 p(p2d.X, y_nodes_min, p2d.Y);
+ if(vmanip.m_data[vmanip.m_area.index(p)].d != CONTENT_AIR)
+ continue;
+ }
+
+ // Ground height at this point
+ float surface_y_f = 0.0;
+
+ // Use perlin noise for ground height
+ surface_y_f = base_rock_level_2d(m_seed, p2d);
+
+ /*// Experimental stuff
+ {
+ float a = highlands_level_2d(m_seed, p2d);
+ if(a > surface_y_f)
+ surface_y_f = a;
+ }*/
+
+ // Convert to integer
+ s16 surface_y = (s16)surface_y_f;
+
+ // Log it
+ if(surface_y > stone_surface_max_y)
+ stone_surface_max_y = surface_y;
+
+ /*
+ Fill ground with stone
+ */
+ {
+ // Use fast index incrementing
+ v3s16 em = vmanip.m_area.getExtent();
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y));
+ for(s16 y=y_nodes_min; y<surface_y && y<=y_nodes_max; y++)
+ {
+ vmanip.m_data[i].d = CONTENT_STONE;
+
+ vmanip.m_area.add_y(em, i, 1);
+ }
+ }
+ }
+
+ }//timer1
+
+ /*
+ Randomize some parameters
+ */
+
+ s32 stone_obstacle_count = 0;
+ /*s32 stone_obstacle_count =
+ rangelim((1.0+noise2d(m_seed+897,
+ sectorpos_base.X, sectorpos_base.Y))/2.0 * 30, 0, 100000);*/
+
+ s16 stone_obstacle_max_height = 0;
+ /*s16 stone_obstacle_max_height =
+ rangelim((1.0+noise2d(m_seed+5902,
+ sectorpos_base.X, sectorpos_base.Y))/2.0 * 30, 0, 100000);*/
+
+ /*
+ Loop this part, it will make stuff look older and newer nicely
+ */
+ //for(u32 i_age=0; i_age<1; i_age++)
+ for(u32 i_age=0; i_age<2; i_age++)
+ { // Aging loop
+
+ {
+ // 8ms @cs=8
+ //TimeTaker timer1("stone obstacles");
+
+ /*
+ Add some random stone obstacles
+ */
+
+ for(s32 ri=0; ri<stone_obstacle_count; ri++)
+ {
+ // Randomize max height so usually stuff will be quite low
+ s16 maxheight_randomized = myrand_range(0, stone_obstacle_max_height);
+
+ //s16 stone_obstacle_max_size = sectorpos_base_size * MAP_BLOCKSIZE - 10;
+ s16 stone_obstacle_max_size = MAP_BLOCKSIZE*4-4;
+
+ v3s16 ob_size(
+ myrand_range(5, stone_obstacle_max_size),
+ myrand_range(0, maxheight_randomized),
+ myrand_range(5, stone_obstacle_max_size)
+ );
+
+ // Don't make stupid small rectangle bumps
+ if(ob_size.Y < 5)
+ continue;
+
+ v2s16 ob_place(
+ myrand_range(1+ob_size.X/2+2,
+ sectorpos_base_size*MAP_BLOCKSIZE-1-1-ob_size.X/2-2),
+ myrand_range(1+ob_size.Z/2+2,
+ sectorpos_base_size*MAP_BLOCKSIZE-1-1-ob_size.Z/2-2)
+ );
+
+ // Minimum space left on top of the obstacle
+ s16 min_head_space = 12;
+
+ for(s16 x=-ob_size.X/2; x<ob_size.X/2; x++)
+ for(s16 z=-ob_size.Z/2; z<ob_size.Z/2; z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + ob_place + v2s16(x,z);
+
+ // Find stone ground level
+ // (ignore everything else than mud in already generated chunks)
+ // and mud amount over the stone level
+ s16 surface_y = 0;
+ s16 mud_amount = 0;
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+ s16 y;
+ // Go to ground level
+ for(y=y_nodes_max; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+ /*if(content_walkable(n.d)
+ && n.d != CONTENT_MUD
+ && n.d != CONTENT_GRASS)
+ break;*/
+ if(n->d == CONTENT_STONE)
+ break;
+
+ if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS)
+ {
+ mud_amount++;
+ /*
+ Change to mud because otherwise we might
+ be throwing mud on grass at the next
+ step
+ */
+ n->d = CONTENT_MUD;
+ }
+
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ if(y >= y_nodes_min)
+ surface_y = y;
+ else
+ surface_y = y_nodes_min;
+ }
+
+
+ /*
+ Add stone on ground
+ */
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = surface_y+1;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ s16 y;
+ // Add stone
+ s16 count = 0;
+ for(y=y_start; y<=y_nodes_max - min_head_space; y++)
+ {
+ MapNode &n = vmanip.m_data[i];
+ n.d = CONTENT_STONE;
+
+ if(y > stone_surface_max_y)
+ stone_surface_max_y = y;
+
+ count++;
+ if(count >= ob_size.Y)
+ break;
+
+ vmanip.m_area.add_y(em, i, 1);
+ }
+ // Add mud
+ count = 0;
+ for(; y<=y_nodes_max - min_head_space; y++)
+ {
+ MapNode &n = vmanip.m_data[i];
+ n.d = CONTENT_MUD;
+ count++;
+ if(count >= mud_amount)
+ break;
+
+ vmanip.m_area.add_y(em, i, 1);
+ }
+ }
+
+ }
+ }
+
+ }//timer1
+ {
+ // 24ms @cs=8
+ //TimeTaker timer1("dungeons");
+
+ /*
+ Make dungeons
+ */
+ u32 dungeons_count = relative_volume / 600000;
+ u32 bruises_count = relative_volume * stone_surface_max_y / 40000000;
+ if(stone_surface_max_y < WATER_LEVEL)
+ bruises_count = 0;
+ /*u32 dungeons_count = 0;
+ u32 bruises_count = 0;*/
+ for(u32 jj=0; jj<dungeons_count+bruises_count; jj++)
+ {
+ s16 min_tunnel_diameter = 2;
+ s16 max_tunnel_diameter = 6;
+ u16 tunnel_routepoints = 25;
+
+ bool bruise_surface = (jj < bruises_count);
+
+ if(bruise_surface)
+ {
+ min_tunnel_diameter = 5;
+ max_tunnel_diameter = myrand_range(10, 20);
+ /*min_tunnel_diameter = MYMAX(0, stone_surface_max_y/6);
+ max_tunnel_diameter = myrand_range(MYMAX(0, stone_surface_max_y/6), MYMAX(0, stone_surface_max_y/2));*/
+
+ /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(m_seed+42,
+ sectorpos_base.X, sectorpos_base.Y)), 0, 15);*/
+
+ tunnel_routepoints = 5;
+ }
+
+ // Allowed route area size in nodes
+ v3s16 ar(
+ sectorpos_base_size*MAP_BLOCKSIZE,
+ h_blocks*MAP_BLOCKSIZE,
+ sectorpos_base_size*MAP_BLOCKSIZE
+ );
+
+ // Area starting point in nodes
+ v3s16 of(
+ sectorpos_base.X*MAP_BLOCKSIZE,
+ y_blocks_min*MAP_BLOCKSIZE,
+ sectorpos_base.Y*MAP_BLOCKSIZE
+ );
+
+ // Allow a bit more
+ //(this should be more than the maximum radius of the tunnel)
+ //s16 insure = 5; // Didn't work with max_d = 20
+ s16 insure = 10;
+ s16 more = max_spread_amount - max_tunnel_diameter/2 - insure;
+ ar += v3s16(1,0,1) * more * 2;
+ of -= v3s16(1,0,1) * more;
+
+ s16 route_y_min = 0;
+ // Allow half a diameter + 7 over stone surface
+ s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7;
+
+ /*// If dungeons, don't go through surface too often
+ if(bruise_surface == false)
+ route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/
+
+ // Limit maximum to area
+ route_y_max = rangelim(route_y_max, 0, ar.Y-1);
+
+ if(bruise_surface)
+ {
+ /*// Minimum is at y=0
+ route_y_min = -of.Y - 0;*/
+ // Minimum is at y=max_tunnel_diameter/4
+ //route_y_min = -of.Y + max_tunnel_diameter/4;
+ //s16 min = -of.Y + max_tunnel_diameter/4;
+ s16 min = -of.Y + 0;
+ route_y_min = myrand_range(min, min + max_tunnel_diameter);
+ route_y_min = rangelim(route_y_min, 0, route_y_max);
+ }
+
+ /*dstream<<"route_y_min = "<<route_y_min
+ <<", route_y_max = "<<route_y_max<<std::endl;*/
+
+ s16 route_start_y_min = route_y_min;
+ s16 route_start_y_max = route_y_max;
+
+ // Start every 2nd dungeon from surface
+ bool coming_from_surface = (jj % 2 == 0 && bruise_surface == false);
+
+ if(coming_from_surface)
+ {
+ route_start_y_min = -of.Y + stone_surface_max_y + 5;
+ }
+
+ route_start_y_min = rangelim(route_start_y_min, 0, ar.Y-1);
+ route_start_y_max = rangelim(route_start_y_max, 0, ar.Y-1);
+
+ // Randomize starting position
+ v3f orp(
+ (float)(myrand()%ar.X)+0.5,
+ (float)(myrand_range(route_start_y_min, route_start_y_max))+0.5,
+ (float)(myrand()%ar.Z)+0.5
+ );
+
+ MapNode airnode(CONTENT_AIR);
+
+ /*
+ Generate some tunnel starting from orp
+ */
+
+ for(u16 j=0; j<tunnel_routepoints; j++)
+ {
+ // Randomize size
+ s16 min_d = min_tunnel_diameter;
+ s16 max_d = max_tunnel_diameter;
+ s16 rs = myrand_range(min_d, max_d);
+
+ v3s16 maxlen;
+ if(bruise_surface)
+ {
+ maxlen = v3s16(rs*7,rs*7,rs*7);
+ }
+ else
+ {
+ maxlen = v3s16(15, myrand_range(1, 20), 15);
+ }
+
+ v3f vec;
+
+ if(coming_from_surface && j < 3)
+ {
+ vec = v3f(
+ (float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+ (float)(myrand()%(maxlen.Y*1))-(float)maxlen.Y,
+ (float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+ );
+ }
+ else
+ {
+ vec = v3f(
+ (float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+ (float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y,
+ (float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+ );
+ }
+
+ v3f rp = orp + vec;
+ if(rp.X < 0)
+ rp.X = 0;
+ else if(rp.X >= ar.X)
+ rp.X = ar.X-1;
+ if(rp.Y < route_y_min)
+ rp.Y = route_y_min;
+ else if(rp.Y >= route_y_max)
+ rp.Y = route_y_max-1;
+ if(rp.Z < 0)
+ rp.Z = 0;
+ else if(rp.Z >= ar.Z)
+ rp.Z = ar.Z-1;
+ vec = rp - orp;
+
+ for(float f=0; f<1.0; f+=1.0/vec.getLength())
+ {
+ v3f fp = orp + vec * f;
+ v3s16 cp(fp.X, fp.Y, fp.Z);
+
+ s16 d0 = -rs/2;
+ s16 d1 = d0 + rs - 1;
+ for(s16 z0=d0; z0<=d1; z0++)
+ {
+ //s16 si = rs - MYMAX(0, abs(z0)-rs/4);
+ s16 si = rs - MYMAX(0, abs(z0)-rs/7);
+ for(s16 x0=-si; x0<=si-1; x0++)
+ {
+ s16 maxabsxz = MYMAX(abs(x0), abs(z0));
+ //s16 si2 = rs - MYMAX(0, maxabsxz-rs/4);
+ s16 si2 = rs - MYMAX(0, maxabsxz-rs/7);
+ //s16 si2 = rs - abs(x0);
+ for(s16 y0=-si2+1+2; y0<=si2-1; y0++)
+ {
+ s16 z = cp.Z + z0;
+ s16 y = cp.Y + y0;
+ s16 x = cp.X + x0;
+ v3s16 p(x,y,z);
+ /*if(isInArea(p, ar) == false)
+ continue;*/
+ // Check only height
+ if(y < 0 || y >= ar.Y)
+ continue;
+ p += of;
+
+ //assert(vmanip.m_area.contains(p));
+ if(vmanip.m_area.contains(p) == false)
+ {
+ dstream<<"WARNING: "<<__FUNCTION_NAME
+ <<":"<<__LINE__<<": "
+ <<"point not in area"
+ <<std::endl;
+ continue;
+ }
+
+ // Just set it to air, it will be changed to
+ // water afterwards
+ u32 i = vmanip.m_area.index(p);
+ vmanip.m_data[i] = airnode;
+
+ if(bruise_surface == false)
+ {
+ // Set tunnel flag
+ vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON;
+ }
+ }
+ }
+ }
+ }
+
+ orp = rp;
+ }
+
+ }
+
+ }//timer1
+ {
+ // 46ms @cs=8
+ //TimeTaker timer1("ore veins");
+
+ /*
+ Make ore veins
+ */
+ for(u32 jj=0; jj<relative_volume/1000; jj++)
+ {
+ s16 max_vein_diameter = 3;
+
+ // Allowed route area size in nodes
+ v3s16 ar(
+ sectorpos_base_size*MAP_BLOCKSIZE,
+ h_blocks*MAP_BLOCKSIZE,
+ sectorpos_base_size*MAP_BLOCKSIZE
+ );
+
+ // Area starting point in nodes
+ v3s16 of(
+ sectorpos_base.X*MAP_BLOCKSIZE,
+ y_blocks_min*MAP_BLOCKSIZE,
+ sectorpos_base.Y*MAP_BLOCKSIZE
+ );
+
+ // Allow a bit more
+ //(this should be more than the maximum radius of the tunnel)
+ s16 insure = 3;
+ s16 more = max_spread_amount - max_vein_diameter/2 - insure;
+ ar += v3s16(1,0,1) * more * 2;
+ of -= v3s16(1,0,1) * more;
+
+ // Randomize starting position
+ v3f orp(
+ (float)(myrand()%ar.X)+0.5,
+ (float)(myrand()%ar.Y)+0.5,
+ (float)(myrand()%ar.Z)+0.5
+ );
+
+ // Randomize mineral
+ u8 mineral;
+ if(myrand()%3 != 0)
+ mineral = MINERAL_COAL;
+ else
+ mineral = MINERAL_IRON;
+
+ /*
+ Generate some vein starting from orp
+ */
+
+ for(u16 j=0; j<2; j++)
+ {
+ /*v3f rp(
+ (float)(myrand()%ar.X)+0.5,
+ (float)(myrand()%ar.Y)+0.5,
+ (float)(myrand()%ar.Z)+0.5
+ );
+ v3f vec = rp - orp;*/
+
+ v3s16 maxlen(5, 5, 5);
+ v3f vec(
+ (float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
+ (float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y,
+ (float)(myrand()%(maxlen.Z*2))-(float)maxlen.Z
+ );
+ v3f rp = orp + vec;
+ if(rp.X < 0)
+ rp.X = 0;
+ else if(rp.X >= ar.X)
+ rp.X = ar.X;
+ if(rp.Y < 0)
+ rp.Y = 0;
+ else if(rp.Y >= ar.Y)
+ rp.Y = ar.Y;
+ if(rp.Z < 0)
+ rp.Z = 0;
+ else if(rp.Z >= ar.Z)
+ rp.Z = ar.Z;
+ vec = rp - orp;
+
+ // Randomize size
+ s16 min_d = 0;
+ s16 max_d = max_vein_diameter;
+ s16 rs = myrand_range(min_d, max_d);
+
+ for(float f=0; f<1.0; f+=1.0/vec.getLength())
+ {
+ v3f fp = orp + vec * f;
+ v3s16 cp(fp.X, fp.Y, fp.Z);
+ s16 d0 = -rs/2;
+ s16 d1 = d0 + rs - 1;
+ for(s16 z0=d0; z0<=d1; z0++)
+ {
+ s16 si = rs - abs(z0);
+ for(s16 x0=-si; x0<=si-1; x0++)
+ {
+ s16 si2 = rs - abs(x0);
+ for(s16 y0=-si2+1; y0<=si2-1; y0++)
+ {
+ // Don't put mineral to every place
+ if(myrand()%5 != 0)
+ continue;
+
+ s16 z = cp.Z + z0;
+ s16 y = cp.Y + y0;
+ s16 x = cp.X + x0;
+ v3s16 p(x,y,z);
+ /*if(isInArea(p, ar) == false)
+ continue;*/
+ // Check only height
+ if(y < 0 || y >= ar.Y)
+ continue;
+ p += of;
+
+ assert(vmanip.m_area.contains(p));
+
+ // Just set it to air, it will be changed to
+ // water afterwards
+ u32 i = vmanip.m_area.index(p);
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d == CONTENT_STONE)
+ n->param = mineral;
+ }
+ }
+ }
+ }
+
+ orp = rp;
+ }
+
+ }
+
+ }//timer1
+ {
+ // 15ms @cs=8
+ //TimeTaker timer1("add mud");
+
+ /*
+ Add mud to the central chunk
+ */
+
+ for(s16 x=0; x<sectorpos_base_size*MAP_BLOCKSIZE; x++)
+ for(s16 z=0; z<sectorpos_base_size*MAP_BLOCKSIZE; z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ // Randomize mud amount
+ s16 mud_add_amount = (s16)(2.5 + 2.0 * noise2d_perlin(
+ 0.5+(float)p2d.X/200, 0.5+(float)p2d.Y/200,
+ m_seed+1, 3, 0.55));
+
+ // Find ground level
+ s16 surface_y = find_ground_level_clever(vmanip, p2d);
+
+ /*
+ If topmost node is grass, change it to mud.
+ It might be if it was flown to there from a neighboring
+ chunk and then converted.
+ */
+ {
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y));
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d == CONTENT_GRASS)
+ n->d = CONTENT_MUD;
+ }
+
+ /*
+ Add mud on ground
+ */
+ {
+ s16 mudcount = 0;
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = surface_y+1;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y<=y_nodes_max; y++)
+ {
+ if(mudcount >= mud_add_amount)
+ break;
+
+ MapNode &n = vmanip.m_data[i];
+ n.d = CONTENT_MUD;
+ mudcount++;
+
+ vmanip.m_area.add_y(em, i, 1);
+ }
+ }
+
+ }
+
+ }//timer1
+ {
+ // 340ms @cs=8
+ TimeTaker timer1("flow mud");
+
+ /*
+ Flow mud away from steep edges
+ */
+
+ // Limit area by 1 because mud is flown into neighbors.
+ s16 mudflow_minpos = 0-max_spread_amount+1;
+ s16 mudflow_maxpos = sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-2;
+
+ // Iterate a few times
+ for(s16 k=0; k<3; k++)
+ {
+
+ for(s16 x=mudflow_minpos;
+ x<=mudflow_maxpos;
+ x++)
+ for(s16 z=mudflow_minpos;
+ z<=mudflow_maxpos;
+ z++)
+ {
+ // Invert coordinates every 2nd iteration
+ if(k%2 == 0)
+ {
+ x = mudflow_maxpos - (x-mudflow_minpos);
+ z = mudflow_maxpos - (z-mudflow_minpos);
+ }
+
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ v3s16 em = vmanip.m_area.getExtent();
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+ s16 y=y_nodes_max;
+
+ for(;; y--)
+ {
+ MapNode *n = NULL;
+ // Find mud
+ for(; y>=y_nodes_min; y--)
+ {
+ n = &vmanip.m_data[i];
+ //if(content_walkable(n->d))
+ // break;
+ if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS)
+ break;
+
+ vmanip.m_area.add_y(em, i, -1);
+ }
+
+ // Stop if out of area
+ //if(vmanip.m_area.contains(i) == false)
+ if(y < y_nodes_min)
+ break;
+
+ /*// If not mud, do nothing to it
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+ continue;*/
+
+ /*
+ Don't flow it if the stuff under it is not mud
+ */
+ {
+ u32 i2 = i;
+ vmanip.m_area.add_y(em, i2, -1);
+ // Cancel if out of area
+ if(vmanip.m_area.contains(i2) == false)
+ continue;
+ MapNode *n2 = &vmanip.m_data[i2];
+ if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS)
+ continue;
+ }
+
+ // Make it exactly mud
+ n->d = CONTENT_MUD;
+
+ /*s16 recurse_count = 0;
+ mudflow_recurse:*/
+
+ v3s16 dirs4[4] = {
+ v3s16(0,0,1), // back
+ v3s16(1,0,0), // right
+ v3s16(0,0,-1), // front
+ v3s16(-1,0,0), // left
+ };
+
+ // Theck that upper is air or doesn't exist.
+ // Cancel dropping if upper keeps it in place
+ u32 i3 = i;
+ vmanip.m_area.add_y(em, i3, 1);
+ if(vmanip.m_area.contains(i3) == true
+ && content_walkable(vmanip.m_data[i3].d) == true)
+ {
+ continue;
+ }
+
+ // Drop mud on side
+
+ for(u32 di=0; di<4; di++)
+ {
+ v3s16 dirp = dirs4[di];
+ u32 i2 = i;
+ // Move to side
+ vmanip.m_area.add_p(em, i2, dirp);
+ // Fail if out of area
+ if(vmanip.m_area.contains(i2) == false)
+ continue;
+ // Check that side is air
+ MapNode *n2 = &vmanip.m_data[i2];
+ if(content_walkable(n2->d))
+ continue;
+ // Check that under side is air
+ vmanip.m_area.add_y(em, i2, -1);
+ if(vmanip.m_area.contains(i2) == false)
+ continue;
+ n2 = &vmanip.m_data[i2];
+ if(content_walkable(n2->d))
+ continue;
+ /*// Check that under that is air (need a drop of 2)
+ vmanip.m_area.add_y(em, i2, -1);
+ if(vmanip.m_area.contains(i2) == false)
+ continue;
+ n2 = &vmanip.m_data[i2];
+ if(content_walkable(n2->d))
+ continue;*/
+ // Loop further down until not air
+ do{
+ vmanip.m_area.add_y(em, i2, -1);
+ // Fail if out of area
+ if(vmanip.m_area.contains(i2) == false)
+ continue;
+ n2 = &vmanip.m_data[i2];
+ }while(content_walkable(n2->d) == false);
+ // Loop one up so that we're in air
+ vmanip.m_area.add_y(em, i2, 1);
+ n2 = &vmanip.m_data[i2];
+
+ // Move mud to new place
+ *n2 = *n;
+ // Set old place to be air
+ *n = MapNode(CONTENT_AIR);
+
+ // Done
+ break;
+ }
+ }
+ }
+
+ }
+
+ }//timer1
+ {
+ // 50ms @cs=8
+ //TimeTaker timer1("add water");
+
+ /*
+ Add water to the central chunk (and a bit more)
+ */
+
+ for(s16 x=0-max_spread_amount;
+ x<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount;
+ x++)
+ for(s16 z=0-max_spread_amount;
+ z<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount;
+ z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ // Find ground level
+ //s16 surface_y = find_ground_level(vmanip, p2d);
+
+ /*
+ If ground level is over water level, skip.
+ NOTE: This leaves caves near water without water,
+ which looks especially crappy when the nearby water
+ won't start flowing either for some reason
+ */
+ /*if(surface_y > WATER_LEVEL)
+ continue;*/
+
+ /*
+ Add water on ground
+ */
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ u8 light = LIGHT_MAX;
+ // Start at global water surface level
+ s16 y_start = WATER_LEVEL;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ MapNode *n = &vmanip.m_data[i];
+
+ /*// Add first one to transforming liquid queue, if water
+ if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE)
+ {
+ v3s16 p = v3s16(p2d.X, y_start, p2d.Y);
+ m_transforming_liquid.push_back(p);
+ }*/
+
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ n = &vmanip.m_data[i];
+
+ // Stop when there is no water and no air
+ if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE
+ && n->d != CONTENT_WATER)
+ {
+ /*// Add bottom one to transforming liquid queue
+ vmanip.m_area.add_y(em, i, 1);
+ n = &vmanip.m_data[i];
+ if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE)
+ {
+ v3s16 p = v3s16(p2d.X, y, p2d.Y);
+ m_transforming_liquid.push_back(p);
+ }*/
+
+ break;
+ }
+
+ // Make water only not in dungeons
+ if(!(vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON))
+ {
+ n->d = CONTENT_WATERSOURCE;
+ //n->setLight(LIGHTBANK_DAY, light);
+
+ // Add to transforming liquid queue (in case it'd
+ // start flowing)
+ v3s16 p = v3s16(p2d.X, y, p2d.Y);
+ m_transforming_liquid.push_back(p);
+ }
+
+ // Next one
+ vmanip.m_area.add_y(em, i, -1);
+ if(light > 0)
+ light--;
+ }
+ }
+
+ }
+
+ }//timer1
+
+ } // Aging loop
+
+ {
+ //TimeTaker timer1("convert mud to sand");
+
+ /*
+ Convert mud to sand
+ */
+
+ //s16 mud_add_amount = myrand_range(2, 4);
+ //s16 mud_add_amount = 0;
+
+ /*for(s16 x=0; x<sectorpos_base_size*MAP_BLOCKSIZE; x++)
+ for(s16 z=0; z<sectorpos_base_size*MAP_BLOCKSIZE; z++)*/
+ for(s16 x=0-max_spread_amount+1;
+ x<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ x++)
+ for(s16 z=0-max_spread_amount+1;
+ z<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ // Determine whether to have sand here
+ double sandnoise = noise2d_perlin(
+ 0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500,
+ m_seed+59420, 3, 0.50);
+
+ bool have_sand = (sandnoise > -0.15);
+
+ if(have_sand == false)
+ continue;
+
+ // Find ground level
+ s16 surface_y = find_ground_level_clever(vmanip, p2d);
+
+ if(surface_y > WATER_LEVEL + 2)
+ continue;
+
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = surface_y;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ u32 not_sand_counter = 0;
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS)
+ {
+ n->d = CONTENT_SAND;
+ }
+ else
+ {
+ not_sand_counter++;
+ if(not_sand_counter > 3)
+ break;
+ }
+
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ }
+
+ }
+
+ }//timer1
+ {
+ // 1ms @cs=8
+ //TimeTaker timer1("generate trees");
+
+ /*
+ Generate some trees
+ */
+ {
+ // Divide area into parts
+ s16 div = 8;
+ s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div;
+ double area = sidelen * sidelen;
+ for(s16 x0=0; x0<div; x0++)
+ for(s16 z0=0; z0<div; z0++)
+ {
+ // Center position of part of division
+ v2s16 p2d_center(
+ sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0,
+ sectorpos_base.Y*MAP_BLOCKSIZE + sidelen/2 + sidelen*z0
+ );
+ // Minimum edge of part of division
+ v2s16 p2d_min(
+ sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0,
+ sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0
+ );
+ // Maximum edge of part of division
+ v2s16 p2d_max(
+ sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1,
+ sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1
+ );
+ // Amount of trees
+ u32 tree_count = area * tree_amount_2d(m_seed, p2d_center);
+ // Put trees in random places on part of division
+ for(u32 i=0; i<tree_count; i++)
+ {
+ s16 x = myrand_range(p2d_min.X, p2d_max.X);
+ s16 z = myrand_range(p2d_min.Y, p2d_max.Y);
+ s16 y = find_ground_level(vmanip, v2s16(x,z));
+ // Don't make a tree under water level
+ if(y < WATER_LEVEL)
+ continue;
+ v3s16 p(x,y,z);
+ /*
+ Trees grow only on mud and grass
+ */
+ {
+ u32 i = vmanip.m_area.index(v3s16(p));
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+ continue;
+ }
+ p.Y++;
+ // Make a tree
+ make_tree(vmanip, p);
+ }
+ }
+ /*u32 tree_max = relative_area / 60;
+ //u32 count = myrand_range(0, tree_max);
+ for(u32 i=0; i<count; i++)
+ {
+ s16 x = myrand_range(0, sectorpos_base_size*MAP_BLOCKSIZE-1);
+ s16 z = myrand_range(0, sectorpos_base_size*MAP_BLOCKSIZE-1);
+ x += sectorpos_base.X*MAP_BLOCKSIZE;
+ z += sectorpos_base.Y*MAP_BLOCKSIZE;
+ s16 y = find_ground_level(vmanip, v2s16(x,z));
+ // Don't make a tree under water level
+ if(y < WATER_LEVEL)
+ continue;
+ v3s16 p(x,y+1,z);
+ // Make a tree
+ make_tree(vmanip, p);
+ }*/
+ }
+
+ }//timer1
+
+ {
+ // 19ms @cs=8
+ //TimeTaker timer1("grow grass");
+
+ /*
+ Grow grass
+ */
+
+ /*for(s16 x=0-4; x<sectorpos_base_size*MAP_BLOCKSIZE+4; x++)
+ for(s16 z=0-4; z<sectorpos_base_size*MAP_BLOCKSIZE+4; z++)*/
+ for(s16 x=0-max_spread_amount;
+ x<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount;
+ x++)
+ for(s16 z=0-max_spread_amount;
+ z<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount;
+ z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ /*
+ Find the lowest surface to which enough light ends up
+ to make grass grow.
+
+ Basically just wait until not air and not leaves.
+ */
+ s16 surface_y = 0;
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y));
+ s16 y;
+ // Go to ground level
+ for(y=y_nodes_max; y>=y_nodes_min; y--)
+ {
+ MapNode &n = vmanip.m_data[i];
+ if(n.d != CONTENT_AIR
+ && n.d != CONTENT_LEAVES)
+ break;
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ if(y >= y_nodes_min)
+ surface_y = y;
+ else
+ surface_y = y_nodes_min;
+ }
+
+ u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y);
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d == CONTENT_MUD)
+ n->d = CONTENT_GRASS;
+ }
+
+ }//timer1
+
+ /*
+ Initial lighting (sunlight)
+ */
- ServerMapSector *sector = new ServerMapSector(this, p2d, hm_split);
+ core::map<v3s16, bool> light_sources;
+
+ {
+ // 750ms @cs=8, can't optimize more
+ TimeTaker timer1("initial lighting");
- /*dstream<<"Generating sector ("<<p2d.X<<","<<p2d.Y<<")"
- " heightmaps and objects"<<std::endl;*/
+#if 0
+ /*
+ Go through the edges and add all nodes that have light to light_sources
+ */
- // Loop through sub-heightmaps
- for(s16 y=0; y<hm_split; y++)
- for(s16 x=0; x<hm_split; x++)
+ // Four edges
+ for(s16 i=0; i<4; i++)
+ // Edge length
+ for(s16 j=lighting_min_d;
+ j<=lighting_max_d;
+ j++)
{
- v2s16 p_in_sector = v2s16(x,y);
- v2s16 mhm_p = p2d * hm_split + p_in_sector;
- f32 corners[4] = {
- m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)),
- m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)),
- m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)),
- m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)),
- };
+ s16 x;
+ s16 z;
+ // +-X
+ if(i == 0 || i == 1)
+ {
+ x = (i==0) ? lighting_min_d : lighting_max_d;
+ if(i == 0)
+ z = lighting_min_d;
+ else
+ z = lighting_max_d;
+ }
+ // +-Z
+ else
+ {
+ z = (i==0) ? lighting_min_d : lighting_max_d;
+ if(i == 0)
+ x = lighting_min_d;
+ else
+ x = lighting_max_d;
+ }
+
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ {
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = y_nodes_max;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+ if(n->getLight(LIGHTBANK_DAY) != 0)
+ {
+ light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+ }
+ //NOTE: This is broken, at least the index has to
+ // be incremented
+ }
+ }
+ }
+#endif
- /*dstream<<"p_in_sector=("<<p_in_sector.X<<","<<p_in_sector.Y<<")"
- <<" mhm_p=("<<mhm_p.X<<","<<mhm_p.Y<<")"
- <<std::endl;*/
+#if 1
+ /*
+ Go through the edges and apply sunlight to them, not caring
+ about neighbors
+ */
+
+ // Four edges
+ for(s16 i=0; i<4; i++)
+ // Edge length
+ for(s16 j=lighting_min_d;
+ j<=lighting_max_d;
+ j++)
+ {
+ s16 x;
+ s16 z;
+ // +-X
+ if(i == 0 || i == 1)
+ {
+ x = (i==0) ? lighting_min_d : lighting_max_d;
+ if(i == 0)
+ z = lighting_min_d;
+ else
+ z = lighting_max_d;
+ }
+ // +-Z
+ else
+ {
+ z = (i==0) ? lighting_min_d : lighting_max_d;
+ if(i == 0)
+ x = lighting_min_d;
+ else
+ x = lighting_max_d;
+ }
+
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ // Loop from top to down
+ {
+ u8 light = LIGHT_SUN;
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = y_nodes_max;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+ if(light_propagates_content(n->d) == false)
+ {
+ light = 0;
+ }
+ else if(light != LIGHT_SUN
+ || sunlight_propagates_content(n->d) == false)
+ {
+ if(light > 0)
+ light--;
+ }
+
+ n->setLight(LIGHTBANK_DAY, light);
+ n->setLight(LIGHTBANK_NIGHT, 0);
+
+ if(light != 0)
+ {
+ // Insert light source
+ light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+ }
+
+ // Increment index by y
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ }
+ }
+#endif
- FixedHeightmap *hm = new FixedHeightmap(&m_hwrapper,
- mhm_p, hm_d);
- sector->setHeightmap(p_in_sector, hm);
+ /*for(s16 x=0; x<sectorpos_base_size*MAP_BLOCKSIZE; x++)
+ for(s16 z=0; z<sectorpos_base_size*MAP_BLOCKSIZE; z++)*/
+ /*for(s16 x=0-max_spread_amount+1;
+ x<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ x++)
+ for(s16 z=0-max_spread_amount+1;
+ z<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ z++)*/
+#if 1
+ /*
+ This has to be 1 smaller than the actual area, because
+ neighboring nodes are checked.
+ */
+ for(s16 x=lighting_min_d+1;
+ x<=lighting_max_d-1;
+ x++)
+ for(s16 z=lighting_min_d+1;
+ z<=lighting_max_d-1;
+ z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ /*
+ Apply initial sunlight
+ */
+ {
+ u8 light = LIGHT_SUN;
+ bool add_to_sources = false;
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = y_nodes_max;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
- //TODO: Make these values configurable
- //hm->generateContinued(0.0, 0.0, corners);
- hm->generateContinued(0.5, 0.2, corners);
- //hm->generateContinued(1.0, 0.2, corners);
- //hm->generateContinued(2.0, 0.2, corners);
+ if(light_propagates_content(n->d) == false)
+ {
+ light = 0;
+ }
+ else if(light != LIGHT_SUN
+ || sunlight_propagates_content(n->d) == false)
+ {
+ if(light > 0)
+ light--;
+ }
+
+ // This doesn't take much time
+ if(add_to_sources == false)
+ {
+ /*
+ Check sides. If side is not air or water, start
+ adding to light_sources.
+ */
+ v3s16 dirs4[4] = {
+ v3s16(0,0,1), // back
+ v3s16(1,0,0), // right
+ v3s16(0,0,-1), // front
+ v3s16(-1,0,0), // left
+ };
+ for(u32 di=0; di<4; di++)
+ {
+ v3s16 dirp = dirs4[di];
+ u32 i2 = i;
+ vmanip.m_area.add_p(em, i2, dirp);
+ MapNode *n2 = &vmanip.m_data[i2];
+ if(
+ n2->d != CONTENT_AIR
+ && n2->d != CONTENT_WATERSOURCE
+ && n2->d != CONTENT_WATER
+ ){
+ add_to_sources = true;
+ break;
+ }
+ }
+ }
+
+ n->setLight(LIGHTBANK_DAY, light);
+ n->setLight(LIGHTBANK_NIGHT, 0);
+
+ // This doesn't take much time
+ if(light != 0 && add_to_sources)
+ {
+ // Insert light source
+ light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+ }
+
+ // Increment index by y
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ }
+ }
+#endif
- //hm->print();
+#if 0
+ for(s16 x=lighting_min_d+1;
+ x<=lighting_max_d-1;
+ x++)
+ for(s16 z=lighting_min_d+1;
+ z<=lighting_max_d-1;
+ z++)
+ {
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+ /*
+ Apply initial sunlight
+ */
+ {
+ u8 light = LIGHT_SUN;
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = y_nodes_max;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+
+ if(light_propagates_content(n->d) == false)
+ {
+ light = 0;
+ }
+ else if(light != LIGHT_SUN
+ || sunlight_propagates_content(n->d) == false)
+ {
+ if(light > 0)
+ light--;
+ }
+
+ n->setLight(LIGHTBANK_DAY, light);
+ n->setLight(LIGHTBANK_NIGHT, 0);
+
+ // This doesn't take much time
+ if(light != 0)
+ {
+ // Insert light source
+ light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+ }
+
+ // Increment index by y
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ }
}
+#endif
+ }//timer1
+
+ // Spread light around
+ {
+ TimeTaker timer("generateChunkRaw() spreadLight");
+ vmanip.spreadLight(LIGHTBANK_DAY, light_sources);
+ }
+
/*
- Generate objects
+ Generation ended
*/
-
- core::map<v3s16, u8> *objects = new core::map<v3s16, u8>;
- sector->setObjects(objects);
-
- v2s16 mhm_p = p2d * hm_split;
- f32 corners[4] = {
- m_heightmap->getGroundHeight(mhm_p+v2s16(0,0)*hm_split),
- m_heightmap->getGroundHeight(mhm_p+v2s16(1,0)*hm_split),
- m_heightmap->getGroundHeight(mhm_p+v2s16(1,1)*hm_split),
- m_heightmap->getGroundHeight(mhm_p+v2s16(0,1)*hm_split),
- };
-
- float avgheight = (corners[0]+corners[1]+corners[2]+corners[3])/4.0;
- float avgslope = 0.0;
- avgslope += fabs(avgheight - corners[0]);
- avgslope += fabs(avgheight - corners[1]);
- avgslope += fabs(avgheight - corners[2]);
- avgslope += fabs(avgheight - corners[3]);
- avgslope /= 4.0;
- avgslope /= MAP_BLOCKSIZE;
- //dstream<<"avgslope="<<avgslope<<std::endl;
-
- float pitness = 0.0;
- v2f32 a;
- a = m_heightmap->getSlope(p2d+v2s16(0,0));
- pitness += -a.X;
- pitness += -a.Y;
- a = m_heightmap->getSlope(p2d+v2s16(0,1));
- pitness += -a.X;
- pitness += a.Y;
- a = m_heightmap->getSlope(p2d+v2s16(1,1));
- pitness += a.X;
- pitness += a.Y;
- a = m_heightmap->getSlope(p2d+v2s16(1,0));
- pitness += a.X;
- pitness += -a.Y;
- pitness /= 4.0;
- pitness /= MAP_BLOCKSIZE;
- //dstream<<"pitness="<<pitness<<std::endl;
-
- /*
- Plant some trees if there is not much slope
- */
- {
- // Avgslope is the derivative of a hill
- float t = avgslope * avgslope;
- float a = MAP_BLOCKSIZE * m_params.plants_amount;
- u32 tree_max;
- if(t > 0.03)
- tree_max = a / (t/0.03);
- else
- tree_max = a;
- u32 count = (rand()%(tree_max+1));
- //u32 count = tree_max;
- for(u32 i=0; i<count; i++)
+
+ timer_generate.stop();
+
+ /*
+ Blit generated stuff to map
+ */
+ {
+ // 70ms @cs=8
+ //TimeTaker timer("generateChunkRaw() blitBackAll");
+ vmanip.blitBackAll(&changed_blocks);
+ }
+
+ /*
+ Update day/night difference cache of the MapBlocks
+ */
+ {
+ for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
+ i.atEnd() == false; i++)
{
- s16 x = (rand()%(MAP_BLOCKSIZE-2))+1;
- s16 z = (rand()%(MAP_BLOCKSIZE-2))+1;
- s16 y = sector->getGroundHeight(v2s16(x,z))+1;
- if(y < WATER_LEVEL)
- continue;
- objects->insert(v3s16(x, y, z),
- SECTOR_OBJECT_TREE_1);
+ MapBlock *block = i.getNode()->getValue();
+ block->updateDayNightDiff();
}
}
+
+
/*
- Plant some bushes if sector is pit-like
+ Create chunk metadata
*/
+
+ for(s16 x=-1; x<=1; x++)
+ for(s16 y=-1; y<=1; y++)
{
- // Pitness usually goes at around -0.5...0.5
- u32 bush_max = 0;
- u32 a = MAP_BLOCKSIZE * 3.0 * m_params.plants_amount;
- if(pitness > 0)
- bush_max = (pitness*a*4);
- if(bush_max > a)
- bush_max = a;
- u32 count = (rand()%(bush_max+1));
- for(u32 i=0; i<count; i++)
+ v2s16 chunkpos0 = chunkpos + v2s16(x,y);
+ // Add chunk meta information
+ MapChunk *chunk = getChunk(chunkpos0);
+ if(chunk == NULL)
{
- s16 x = rand()%(MAP_BLOCKSIZE-0)+0;
- s16 z = rand()%(MAP_BLOCKSIZE-0)+0;
- s16 y = sector->getGroundHeight(v2s16(x,z))+1;
- if(y < WATER_LEVEL)
- continue;
- objects->insert(v3s16(x, y, z),
- SECTOR_OBJECT_BUSH_1);
+ chunk = new MapChunk();
+ m_chunks.insert(chunkpos0, chunk);
}
+ //chunk->setIsVolatile(true);
+ if(chunk->getGenLevel() > GENERATED_PARTLY)
+ chunk->setGenLevel(GENERATED_PARTLY);
+ }
+
+ /*
+ Set central chunk non-volatile
+ */
+ MapChunk *chunk = getChunk(chunkpos);
+ assert(chunk);
+ // Set non-volatile
+ //chunk->setIsVolatile(false);
+ chunk->setGenLevel(GENERATED_FULLY);
+
+ /*
+ Save changed parts of map
+ */
+ save(true);
+
+ /*
+ Return central chunk (which was requested)
+ */
+ return chunk;
+}
+
+MapChunk* ServerMap::generateChunk(v2s16 chunkpos1,
+ core::map<v3s16, MapBlock*> &changed_blocks)
+{
+ dstream<<"generateChunk(): Generating chunk "
+ <<"("<<chunkpos1.X<<","<<chunkpos1.Y<<")"
+ <<std::endl;
+
+ /*for(s16 x=-1; x<=1; x++)
+ for(s16 y=-1; y<=1; y++)*/
+ for(s16 x=-0; x<=0; x++)
+ for(s16 y=-0; y<=0; y++)
+ {
+ v2s16 chunkpos0 = chunkpos1 + v2s16(x,y);
+ MapChunk *chunk = getChunk(chunkpos0);
+ // Skip if already generated
+ if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY)
+ continue;
+ generateChunkRaw(chunkpos0, changed_blocks);
}
+
+ assert(chunkNonVolatile(chunkpos1));
+
+ MapChunk *chunk = getChunk(chunkpos1);
+ return chunk;
+}
+
+ServerMapSector * ServerMap::createSector(v2s16 p2d)
+{
+ DSTACK("%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;
+
/*
- Add ravine (randomly)
+ Try to load it from disk (with blocks)
*/
- if(m_params.ravines_amount != 0)
+ if(loadSectorFull(p2d) == true)
{
- if(rand()%(s32)(20.0 / m_params.ravines_amount) == 0)
+ ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d);
+ if(sector == NULL)
{
- s16 s = 6;
- s16 x = rand()%(MAP_BLOCKSIZE-s*2-1)+s;
- s16 z = rand()%(MAP_BLOCKSIZE-s*2-1)+s;
- /*s16 x = 8;
- s16 z = 8;*/
- s16 y = sector->getGroundHeight(v2s16(x,z))+1;
- objects->insert(v3s16(x, y, z),
- SECTOR_OBJECT_RAVINE);
+ dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"<<std::endl;
+ throw InvalidPositionException("");
}
+ return sector;
}
+ /*
+ 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);
+
+ // Sector position on map in nodes
+ v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
+
/*
Insert to container
*/
- JMutexAutoLock lock(m_sector_mutex);
m_sectors.insert(p2d, sector);
return sector;
}
-MapBlock * ServerMap::emergeBlock(
- v3s16 p,
- bool only_from_disk,
- core::map<v3s16, MapBlock*> &changed_blocks,
- core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
-)
+MapSector * ServerMap::emergeSector(v2s16 p2d,
+ core::map<v3s16, MapBlock*> &changed_blocks)
{
- DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d",
+ DSTACK("%s: p2d=(%d,%d)",
__FUNCTION_NAME,
- p.X, p.Y, p.Z, only_from_disk);
-
- /*dstream<<"ServerMap::emergeBlock(): "
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<", only_from_disk="<<only_from_disk<<std::endl;*/
- v2s16 p2d(p.X, p.Z);
- s16 block_y = p.Y;
+ p2d.X, p2d.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.
+ Check chunk status
*/
- ServerMapSector *sector = (ServerMapSector*)emergeSector(p2d);
- assert(sector->getId() == MAPSECTOR_SERVER);
+ v2s16 chunkpos = sector_to_chunk(p2d);
+ /*bool chunk_nonvolatile = false;
+ MapChunk *chunk = getChunk(chunkpos);
+ if(chunk && chunk->getIsVolatile() == false)
+ chunk_nonvolatile = true;*/
+ bool chunk_nonvolatile = chunkNonVolatile(chunkpos);
- // Try to get a block from the sector
- MapBlock *block = NULL;
- bool not_on_disk = false;
- try{
- block = sector->getBlockNoCreate(block_y);
- if(block->isDummy() == true)
- not_on_disk = true;
- else
- return block;
- }
- catch(InvalidPositionException &e)
+ /*
+ If chunk is not fully generated, generate chunk
+ */
+ if(chunk_nonvolatile == false)
{
- not_on_disk = true;
+ // Generate chunk and neighbors
+ generateChunk(chunkpos, changed_blocks);
}
/*
- If block was not found on disk and not going to generate a
- new one, make sure there is a dummy block in place.
+ Return sector if it exists now
+ */
+ MapSector *sector = getSectorNoGenerateNoEx(p2d);
+ if(sector != NULL)
+ return sector;
+
+ /*
+ Try to load it from disk
*/
- if(not_on_disk && only_from_disk)
+ if(loadSectorFull(p2d) == true)
{
- if(block == NULL)
+ MapSector *sector = getSectorNoGenerateNoEx(p2d);
+ if(sector == NULL)
{
- // Create dummy block
- block = new MapBlock(this, p, true);
-
- // Add block to sector
- sector->insertBlock(block);
+ dstream<<"ServerMap::emergeSector(): loadSectorFull didn't make a sector"<<std::endl;
+ throw InvalidPositionException("");
}
- // Done.
- return block;
+ return sector;
}
- //dstream<<"Not found on disk, generating."<<std::endl;
- //TimeTaker("emergeBlock()", g_irrlicht);
+ /*
+ generateChunk should have generated the sector
+ */
+ //assert(0);
+
+ dstream<<"WARNING: ServerMap::emergeSector: Cannot find sector ("
+ <<p2d.X<<","<<p2d.Y<<" and chunk is already generated. "
+ <<std::endl;
+
+#if 0
+ dstream<<"WARNING: Creating an empty sector."<<std::endl;
+
+ return createSector(p2d);
+
+#endif
+
+#if 1
+ dstream<<"WARNING: Forcing regeneration of chunk."<<std::endl;
+
+ // Generate chunk
+ generateChunkRaw(chunkpos, changed_blocks, true);
+
+ /*
+ Return sector if it exists now
+ */
+ sector = getSectorNoGenerateNoEx(p2d);
+ if(sector != NULL)
+ return sector;
+
+ dstream<<"ERROR: Could not get sector from anywhere."<<std::endl;
+
+ assert(0);
+#endif
+
+ /*
+ Generate directly
+ */
+ //return generateSector();
+}
+/*
+ NOTE: This is not used for main map generation, only for blocks
+ that are very high or low
+*/
+MapBlock * ServerMap::generateBlock(
+ v3s16 p,
+ MapBlock *original_dummy,
+ ServerMapSector *sector,
+ core::map<v3s16, MapBlock*> &changed_blocks,
+ core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+)
+{
+ DSTACK("%s: p=(%d,%d,%d)",
+ __FUNCTION_NAME,
+ p.X, p.Y, p.Z);
+
+ /*dstream<<"generateBlock(): "
+ <<"("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+ <<std::endl;*/
+
+ MapBlock *block = original_dummy;
+
+ v2s16 p2d(p.X, p.Z);
+ s16 block_y = p.Y;
+
/*
Do not generate over-limit
*/
if(blockpos_over_limit(p))
- throw InvalidPositionException("emergeBlock(): pos. over limit");
-
- /*
- OK; Not found.
-
- Go on generating the block.
+ {
+ dstream<<__FUNCTION_NAME<<": Block position over limit"<<std::endl;
+ throw InvalidPositionException("generateBlock(): pos. over limit");
+ }
- TODO: If a dungeon gets generated so that it's side gets
- revealed to the outside air, the lighting should be
- recalculated.
- */
-
/*
If block doesn't exist, create one.
If it exists, it is a dummy. In that case unDummify() it.
+
+ NOTE: This already sets the map as the parent of the block
*/
if(block == NULL)
{
{
// Remove the block so that nobody can get a half-generated one.
sector->removeBlock(block);
- // Allocate the block to be a proper one.
+ // Allocate the block to contain the generated data
block->unDummify();
}
-#if 0
- /*
- Initialize dungeon making by creating a random table
- */
- const s32 ued_max = 5;
- const s32 ued_min = 3;
- bool underground_emptiness[ued_max*ued_max*ued_max];
- s32 ued = (rand()%(ued_max-ued_min+1))+1;
- //s32 ued = ued_max;
- for(s32 i=0; i<ued*ued*ued; i++)
+ u8 water_material = CONTENT_WATERSOURCE;
+
+ s32 lowest_ground_y = 32767;
+ s32 highest_ground_y = -32768;
+
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
- underground_emptiness[i] = ((rand() % 5) == 0);
- }
+ //dstream<<"generateBlock: x0="<<x0<<", z0="<<z0<<std::endl;
- /*
- This is a messy hack to sort the emptiness a bit
- */
- // Iterator through a few times
- for(s32 j=0; j<2; j++)
- for(s32 y0=0; y0<ued; y0++)
- for(s32 z0=0; z0<ued; z0++)
- for(s32 x0=0; x0<ued; x0++)
- {
- v3s16 p0(x0,y0,z0);
- bool &e0 = underground_emptiness[
- ued*ued*(z0*ued/MAP_BLOCKSIZE)
- +ued*(y0*ued/MAP_BLOCKSIZE)
- +(x0*ued/MAP_BLOCKSIZE)];
-
- v3s16 dirs[6] = {
- v3s16(0,0,1), // back
- v3s16(1,0,0), // right
- v3s16(0,0,-1), // front
- v3s16(-1,0,0), // left
- /*v3s16(0,1,0), // top
- v3s16(0,-1,0), // bottom*/
- };
+ s16 surface_y = 0;
+
+ if(surface_y < lowest_ground_y)
+ lowest_ground_y = surface_y;
+ if(surface_y > highest_ground_y)
+ highest_ground_y = surface_y;
- for(s32 i=0; i<4; i++)
+ s32 surface_depth = 2;
+
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
- v3s16 p1 = p0 + dirs[i];
- if(isInArea(p1, ued) == false)
- continue;
- bool &e1 = underground_emptiness[
- ued*ued*(p1.Z*ued/MAP_BLOCKSIZE)
- +ued*(p1.Y*ued/MAP_BLOCKSIZE)
- +(p1.X*ued/MAP_BLOCKSIZE)];
- if(e0 == e1)
- continue;
+ s16 real_y = block_y * MAP_BLOCKSIZE + y0;
+ MapNode n;
+ /*
+ Calculate lighting
- v3s16 dirs[6] = {
- v3s16(0,1,0), // top
- v3s16(0,-1,0), // bottom
- /*v3s16(0,0,1), // back
- v3s16(1,0,0), // right
- v3s16(0,0,-1), // front
- v3s16(-1,0,0), // left*/
- };
- for(s32 i=0; i<2; i++)
+ NOTE: If there are some man-made structures above the
+ newly created block, they won't be taken into account.
+ */
+ if(real_y > surface_y)
+ n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
+
+ /*
+ Calculate material
+ */
+
+ // If node is over heightmap y, it's air or water
+ if(real_y > surface_y)
{
- v3s16 p2 = p1 + dirs[i];
- if(p2 == p0)
- continue;
- if(isInArea(p2, ued) == false)
- continue;
- bool &e2 = underground_emptiness[
- ued*ued*(p2.Z*ued/MAP_BLOCKSIZE)
- +ued*(p2.Y*ued/MAP_BLOCKSIZE)
- +(p2.X*ued/MAP_BLOCKSIZE)];
- if(e2 != e0)
- continue;
-
- bool t = e1;
- e1 = e2;
- e2 = t;
+ // If under water level, it's water
+ if(real_y < WATER_LEVEL)
+ {
+ n.d = water_material;
+ n.setLight(LIGHTBANK_DAY,
+ diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
+ /*
+ Add to transforming liquid queue (in case it'd
+ start flowing)
+ */
+ v3s16 real_pos = v3s16(x0,y0,z0) + p*MAP_BLOCKSIZE;
+ m_transforming_liquid.push_back(real_pos);
+ }
+ // else air
+ else
+ n.d = CONTENT_AIR;
+ }
+ // Else it's ground or dungeons (air)
+ else
+ {
+ // If it's surface_depth under ground, it's stone
+ if(real_y <= surface_y - surface_depth)
+ {
+ n.d = CONTENT_STONE;
+ }
+ else
+ {
+ // It is mud if it is under the first ground
+ // level or under water
+ if(real_y < WATER_LEVEL || real_y <= surface_y - 1)
+ {
+ n.d = CONTENT_MUD;
+ }
+ else
+ {
+ n.d = CONTENT_GRASS;
+ }
- break;
+ //n.d = CONTENT_MUD;
+
+ /*// If under water level, it's mud
+ if(real_y < WATER_LEVEL)
+ n.d = CONTENT_MUD;
+ // Only the topmost node is grass
+ else if(real_y <= surface_y - 1)
+ n.d = CONTENT_MUD;
+ else
+ n.d = CONTENT_GRASS;*/
+ }
}
- //break;
+
+ block->setNode(v3s16(x0,y0,z0), n);
}
}
+
+ /*
+ Calculate some helper variables
+ */
+
+ // Completely underground if the highest part of block is under lowest
+ // ground height.
+ // This has to be very sure; it's probably one too strict now but
+ // that's just better.
+ bool completely_underground =
+ block_y * MAP_BLOCKSIZE + MAP_BLOCKSIZE < lowest_ground_y;
+
+ bool some_part_underground = block_y * MAP_BLOCKSIZE <= highest_ground_y;
+
+ bool mostly_underwater_surface = false;
+ if(highest_ground_y < WATER_LEVEL
+ && some_part_underground && !completely_underground)
+ mostly_underwater_surface = true;
+
+ /*
+ Get local attributes
+ */
+
+ //dstream<<"generateBlock(): Getting local attributes"<<std::endl;
+
+ float caves_amount = 0.5;
+
+#if 0
+ {
+ /*
+ NOTE: BEWARE: Too big amount of attribute points slows verything
+ down by a lot.
+ 1 interpolation from 5000 points takes 2-3ms.
+ */
+ //TimeTaker timer("generateBlock() local attribute retrieval");
+ v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
+ PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
+ caves_amount = list_caves_amount->getInterpolatedFloat(nodepos2d);
+ }
#endif
+ //dstream<<"generateBlock(): Done"<<std::endl;
+
/*
- Create dungeon making table
+ Generate dungeons
*/
+
+ // Initialize temporary table
const s32 ued = MAP_BLOCKSIZE;
bool underground_emptiness[ued*ued*ued];
for(s32 i=0; i<ued*ued*ued; i++)
{
underground_emptiness[i] = 0;
}
- // Generate dungeons
+
+ // Fill table
+#if 1
{
/*
Initialize orp and ors. Try to find if some neighboring
*/
v3f orp(
- (float)(rand()%ued)+0.5,
- (float)(rand()%ued)+0.5,
- (float)(rand()%ued)+0.5
+ (float)(myrand()%ued)+0.5,
+ (float)(myrand()%ued)+0.5,
+ (float)(myrand()%ued)+0.5
);
+
+ bool found_existing = false;
// Check z-
try
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(x+1,y+1,0);
+ found_existing = true;
goto continue_generating;
}
}
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(x+1,y+1,ued-1);
+ found_existing = true;
goto continue_generating;
}
}
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(0,y+1,z+1);
+ found_existing = true;
goto continue_generating;
}
}
if(getNode(ap).d == CONTENT_AIR)
{
orp = v3f(ued-1,y+1,z+1);
+ found_existing = true;
+ goto continue_generating;
+ }
+ }
+ }
+ catch(InvalidPositionException &e){}
+
+ // Check y-
+ try
+ {
+ s16 y = -1;
+ for(s16 x=0; x<ued; x++)
+ for(s16 z=0; z<ued; z++)
+ {
+ v3s16 ap = v3s16(x,y,z) + block->getPosRelative();
+ if(getNode(ap).d == CONTENT_AIR)
+ {
+ orp = v3f(x+1,0,z+1);
+ found_existing = true;
+ goto continue_generating;
+ }
+ }
+ }
+ catch(InvalidPositionException &e){}
+
+ // Check y+
+ try
+ {
+ s16 y = ued;
+ for(s16 x=0; x<ued; x++)
+ for(s16 z=0; z<ued; z++)
+ {
+ v3s16 ap = v3s16(x,y,z) + block->getPosRelative();
+ if(getNode(ap).d == CONTENT_AIR)
+ {
+ orp = v3f(x+1,ued-1,z+1);
+ found_existing = true;
goto continue_generating;
}
}
continue_generating:
/*
- Generate some tunnel starting from orp and ors
+ Choose whether to actually generate dungeon
*/
- for(u16 i=0; i<3; i++)
+ bool do_generate_dungeons = true;
+ // Don't generate if no part is underground
+ if(!some_part_underground)
{
- v3f rp(
- (float)(rand()%ued)+0.5,
- (float)(rand()%ued)+0.5,
- (float)(rand()%ued)+0.5
- );
- s16 min_d = 0;
- s16 max_d = 4;
- s16 rs = (rand()%(max_d-min_d+1))+min_d;
-
- v3f vec = rp - orp;
+ do_generate_dungeons = false;
+ }
+ // Don't generate if mostly underwater surface
+ /*else if(mostly_underwater_surface)
+ {
+ do_generate_dungeons = false;
+ }*/
+ // Partly underground = cave
+ else if(!completely_underground)
+ {
+ do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
+ }
+ // Found existing dungeon underground
+ else if(found_existing && completely_underground)
+ {
+ do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
+ }
+ // Underground and no dungeons found
+ else
+ {
+ do_generate_dungeons = (rand() % 300 <= (s32)(caves_amount*100));
+ }
- for(float f=0; f<1.0; f+=0.04)
+ if(do_generate_dungeons)
+ {
+ /*
+ Generate some tunnel starting from orp and ors
+ */
+ for(u16 i=0; i<3; i++)
{
- v3f fp = orp + vec * f;
- v3s16 cp(fp.X, fp.Y, fp.Z);
- s16 d0 = -rs/2;
- s16 d1 = d0 + rs - 1;
- for(s16 z0=d0; z0<=d1; z0++)
+ v3f rp(
+ (float)(myrand()%ued)+0.5,
+ (float)(myrand()%ued)+0.5,
+ (float)(myrand()%ued)+0.5
+ );
+ s16 min_d = 0;
+ s16 max_d = 4;
+ s16 rs = (myrand()%(max_d-min_d+1))+min_d;
+
+ v3f vec = rp - orp;
+
+ for(float f=0; f<1.0; f+=0.04)
{
- s16 si = rs - abs(z0);
- for(s16 x0=-si; x0<=si-1; x0++)
+ v3f fp = orp + vec * f;
+ v3s16 cp(fp.X, fp.Y, fp.Z);
+ s16 d0 = -rs/2;
+ s16 d1 = d0 + rs - 1;
+ for(s16 z0=d0; z0<=d1; z0++)
{
- s16 si2 = rs - abs(x0);
- for(s16 y0=-si2+1; y0<=si2-1; y0++)
+ s16 si = rs - abs(z0);
+ for(s16 x0=-si; x0<=si-1; x0++)
{
- s16 z = cp.Z + z0;
- s16 y = cp.Y + y0;
- s16 x = cp.X + x0;
- v3s16 p(x,y,z);
- if(isInArea(p, ued) == false)
- continue;
- underground_emptiness[ued*ued*z + ued*y + x] = 1;
+ s16 si2 = rs - abs(x0);
+ for(s16 y0=-si2+1; y0<=si2-1; y0++)
+ {
+ s16 z = cp.Z + z0;
+ s16 y = cp.Y + y0;
+ s16 x = cp.X + x0;
+ v3s16 p(x,y,z);
+ if(isInArea(p, ued) == false)
+ continue;
+ underground_emptiness[ued*ued*z + ued*y + x] = 1;
+ }
}
}
}
- }
- orp = rp;
+ orp = rp;
+ }
}
}
-
- // This is the basic material of what the visible flat ground
- // will consist of
- u8 material = CONTENT_GRASS;
+#endif
- u8 water_material = CONTENT_WATER;
- if(g_settings.getBool("endless_water"))
- water_material = CONTENT_OCEAN;
-
- s32 lowest_ground_y = 32767;
- s32 highest_ground_y = -32768;
-
- // DEBUG
- //sector->printHeightmaps();
+ // Set to true if has caves.
+ // Set when some non-air is changed to air when making caves.
+ bool has_dungeons = false;
+
+ /*
+ Apply temporary cave data to block
+ */
for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
- //dstream<<"emergeBlock: x0="<<x0<<", z0="<<z0<<std::endl;
-
- float surface_y_f = sector->getGroundHeight(v2s16(x0,z0));
- //assert(surface_y_f > GROUNDHEIGHT_VALID_MINVALUE);
- if(surface_y_f < GROUNDHEIGHT_VALID_MINVALUE)
- {
- dstream<<"WARNING: Surface height not found in sector "
- "for block that is being emerged"<<std::endl;
- surface_y_f = 0.0;
- }
-
- s16 surface_y = surface_y_f;
- //avg_ground_y += surface_y;
- if(surface_y < lowest_ground_y)
- lowest_ground_y = surface_y;
- if(surface_y > highest_ground_y)
- highest_ground_y = surface_y;
-
- s32 surface_depth = 0;
-
- float slope = sector->getSlope(v2s16(x0,z0)).getLength();
-
- //float min_slope = 0.45;
- //float max_slope = 0.85;
- float min_slope = 0.60;
- float max_slope = 1.20;
- float min_slope_depth = 5.0;
- float max_slope_depth = 0;
- if(slope < min_slope)
- surface_depth = min_slope_depth;
- else if(slope > max_slope)
- surface_depth = max_slope_depth;
- else
- surface_depth = (1.-(slope-min_slope)/max_slope) * min_slope_depth;
-
for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
- s16 real_y = block_y * MAP_BLOCKSIZE + y0;
- MapNode n;
- /*
- Calculate lighting
-
- NOTE: If there are some man-made structures above the
- newly created block, they won't be taken into account.
- */
- if(real_y > surface_y)
- n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
-
- /*
- Calculate material
- */
+ MapNode n = block->getNode(v3s16(x0,y0,z0));
- if(real_y <= surface_y - surface_depth)
+ // Create dungeons
+ if(underground_emptiness[
+ ued*ued*(z0*ued/MAP_BLOCKSIZE)
+ +ued*(y0*ued/MAP_BLOCKSIZE)
+ +(x0*ued/MAP_BLOCKSIZE)])
{
- // Create dungeons
- if(underground_emptiness[
- ued*ued*(z0*ued/MAP_BLOCKSIZE)
- +ued*(y0*ued/MAP_BLOCKSIZE)
- +(x0*ued/MAP_BLOCKSIZE)])
+ if(content_features(n.d).walkable/*is_ground_content(n.d)*/)
{
+ // Has now caves
+ has_dungeons = true;
+ // Set air to node
n.d = CONTENT_AIR;
}
- else
- {
- n.d = CONTENT_STONE;
- }
- }
- // If node is at or under heightmap y
- else if(real_y <= surface_y)
- {
- // If under water level, it's mud
- if(real_y < WATER_LEVEL)
- n.d = CONTENT_MUD;
- // Only the topmost node is grass
- else if(real_y <= surface_y - 1)
- n.d = CONTENT_MUD;
- // Else it's the main material
- else
- n.d = material;
- }
- // If node is over heightmap y
- else{
- // If under water level, it's water
- if(real_y < WATER_LEVEL)
- {
- n.d = water_material;
- n.setLight(LIGHTBANK_DAY,
- diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
- }
- // else air
- else
- n.d = CONTENT_AIR;
}
+
block->setNode(v3s16(x0,y0,z0), n);
}
}
-
+
/*
- Calculate is_underground
+ This is used for guessing whether or not the block should
+ receive sunlight from the top if the block above doesn't exist
*/
- // Probably underground if the highest part of block is under lowest
- // ground height
- bool is_underground = (block_y+1) * MAP_BLOCKSIZE <= lowest_ground_y;
- block->setIsUnderground(is_underground);
+ block->setIsUnderground(completely_underground);
/*
- Force lighting update if some part of block is underground
- This is needed because of caves.
+ Force lighting update if some part of block is partly
+ underground and has caves.
*/
-
- bool some_part_underground = (block_y+0) * MAP_BLOCKSIZE < highest_ground_y;
- if(some_part_underground)
- //if(is_underground)
+ /*if(some_part_underground && !completely_underground && has_dungeons)
{
+ //dstream<<"Half-ground caves"<<std::endl;
lighting_invalidated_blocks[block->getPos()] = block;
- }
+ }*/
+ // DEBUG: Always update lighting
+ //lighting_invalidated_blocks[block->getPos()] = block;
+
/*
Add some minerals
*/
/*
Add meseblocks
*/
- for(s16 i=0; i<underground_level*1; i++)
+ for(s16 i=0; i<underground_level/4 + 1; i++)
+ {
+ if(myrand()%50 == 0)
+ {
+ v3s16 cp(
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1
+ );
+
+ MapNode n;
+ n.d = CONTENT_MESE;
+
+ for(u16 i=0; i<27; i++)
+ {
+ if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
+ if(myrand()%8 == 0)
+ block->setNode(cp+g_27dirs[i], n);
+ }
+ }
+ }
+
+ /*
+ Add coal
+ */
+ u16 coal_amount = 30;
+ u16 coal_rareness = 60 / coal_amount;
+ if(coal_rareness == 0)
+ coal_rareness = 1;
+ if(myrand()%coal_rareness == 0)
{
- if(rand()%2 == 0)
+ u16 a = myrand() % 16;
+ u16 amount = coal_amount * a*a*a / 1000;
+ for(s16 i=0; i<amount; i++)
{
v3s16 cp(
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1
);
MapNode n;
- n.d = CONTENT_MESE;
-
- //if(is_ground_content(block->getNode(cp).d))
- if(block->getNode(cp).d == CONTENT_STONE)
- if(rand()%8 == 0)
- block->setNode(cp, n);
+ n.d = CONTENT_STONE;
+ n.param = MINERAL_COAL;
- for(u16 i=0; i<26; i++)
+ for(u16 i=0; i<27; i++)
{
- //if(is_ground_content(block->getNode(cp+g_26dirs[i]).d))
- if(block->getNode(cp+g_26dirs[i]).d == CONTENT_STONE)
- if(rand()%8 == 0)
- block->setNode(cp+g_26dirs[i], n);
+ if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
+ if(myrand()%8 == 0)
+ block->setNode(cp+g_27dirs[i], n);
}
}
}
/*
- Add coal
+ Add iron
*/
- u16 coal_amount = 30.0 * g_settings.getFloat("coal_amount");
- u16 coal_rareness = 60 / coal_amount;
- if(coal_rareness == 0)
- coal_rareness = 1;
- if(rand()%coal_rareness == 0)
+ //TODO: change to iron_amount or whatever
+ u16 iron_amount = 15;
+ u16 iron_rareness = 60 / iron_amount;
+ if(iron_rareness == 0)
+ iron_rareness = 1;
+ if(myrand()%iron_rareness == 0)
{
- u16 a = rand() % 16;
- u16 amount = coal_amount * a*a*a / 1000;
+ u16 a = myrand() % 16;
+ u16 amount = iron_amount * a*a*a / 1000;
for(s16 i=0; i<amount; i++)
{
v3s16 cp(
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1
);
MapNode n;
- n.d = CONTENT_COALSTONE;
-
- //dstream<<"Adding coalstone"<<std::endl;
-
- //if(is_ground_content(block->getNode(cp).d))
- if(block->getNode(cp).d == CONTENT_STONE)
- if(rand()%8 == 0)
- block->setNode(cp, n);
+ n.d = CONTENT_STONE;
+ n.param = MINERAL_IRON;
- for(u16 i=0; i<26; i++)
+ for(u16 i=0; i<27; i++)
{
- //if(is_ground_content(block->getNode(cp+g_26dirs[i]).d))
- if(block->getNode(cp+g_26dirs[i]).d == CONTENT_STONE)
- if(rand()%8 == 0)
- block->setNode(cp+g_26dirs[i], n);
+ if(block->getNode(cp+g_27dirs[i]).d == CONTENT_STONE)
+ if(myrand()%8 == 0)
+ block->setNode(cp+g_27dirs[i], n);
}
}
}
/*
Create a few rats in empty blocks underground
*/
- if(is_underground)
+ if(completely_underground)
{
//for(u16 i=0; i<2; i++)
{
v3s16 cp(
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1,
- (rand()%(MAP_BLOCKSIZE-2))+1
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1,
+ (myrand()%(MAP_BLOCKSIZE-2))+1
);
// Check that the place is empty
*/
sector->insertBlock(block);
+ // Lighting is invalid after generation.
+ block->setLightingExpired(true);
+
+#if 0
/*
- Sector object stuff
+ Debug information
*/
-
- // An y-wise container of changed blocks
- core::map<s16, MapBlock*> changed_blocks_sector;
+ dstream
+ <<"lighting_invalidated_blocks.size()"
+ <<", has_dungeons"
+ <<", completely_ug"
+ <<", some_part_ug"
+ <<" "<<lighting_invalidated_blocks.size()
+ <<", "<<has_dungeons
+ <<", "<<completely_underground
+ <<", "<<some_part_underground
+ <<std::endl;
+#endif
+
+ return block;
+}
+MapBlock * ServerMap::createBlock(v3s16 p)
+{
+ DSTACK("%s: p=(%d,%d,%d)",
+ __FUNCTION_NAME, p.X, p.Y, p.Z);
+
+ v2s16 p2d(p.X, p.Z);
+ s16 block_y = p.Y;
/*
- Check if any sector's objects can be placed now.
- If so, place them.
+ 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.
*/
- core::map<v3s16, u8> *objects = sector->getObjects();
- core::list<v3s16> objects_to_remove;
- for(core::map<v3s16, u8>::Iterator i = objects->getIterator();
- i.atEnd() == false; i++)
+ ServerMapSector *sector;
+ try{
+ sector = (ServerMapSector*)createSector(p2d);
+ assert(sector->getId() == MAPSECTOR_SERVER);
+ }
+ /*catch(InvalidPositionException &e)
{
- v3s16 p = i.getNode()->getKey();
- v2s16 p2d(p.X,p.Z);
- u8 d = i.getNode()->getValue();
+ dstream<<"createBlock: createSector() failed"<<std::endl;
+ throw e;
+ }*/
+ catch(std::exception &e)
+ {
+ dstream<<"createBlock: createSector() failed: "
+ <<e.what()<<std::endl;
+ throw e;
+ }
- //v3s16 p = p_sector - v3s16(0, block_y*MAP_BLOCKSIZE, 0);
-
- try
- {
+ /*
+ Try to get a block from the sector
+ */
- if(d == SECTOR_OBJECT_TEST)
- {
- if(sector->isValidArea(p + v3s16(0,0,0),
- p + v3s16(0,0,0), &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_TORCH;
- sector->setNode(p, n);
- objects_to_remove.push_back(p);
- }
- }
- else if(d == SECTOR_OBJECT_TREE_1)
- {
- v3s16 p_min = p + v3s16(-1,0,-1);
- v3s16 p_max = p + v3s16(1,4,1);
- if(sector->isValidArea(p_min, p_max,
- &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_TREE;
- sector->setNode(p+v3s16(0,0,0), n);
- sector->setNode(p+v3s16(0,1,0), n);
- sector->setNode(p+v3s16(0,2,0), n);
- sector->setNode(p+v3s16(0,3,0), n);
+ MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
+ if(block)
+ return block;
+ // Create blank
+ block = sector->createBlankBlock(block_y);
+ return block;
+}
- n.d = CONTENT_LEAVES;
+MapBlock * ServerMap::emergeBlock(
+ v3s16 p,
+ bool only_from_disk,
+ core::map<v3s16, MapBlock*> &changed_blocks,
+ core::map<v3s16, MapBlock*> &lighting_invalidated_blocks
+)
+{
+ DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d",
+ __FUNCTION_NAME,
+ p.X, p.Y, p.Z, only_from_disk);
+
+ 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 = (ServerMapSector*)emergeSector(p2d, changed_blocks);
+ assert(sector->getId() == MAPSECTOR_SERVER);
+ }
+ catch(std::exception &e)
+ {
+ dstream<<"emergeBlock: emergeSector() failed: "
+ <<e.what()<<std::endl;
+ dstream<<"Path to failed sector: "<<getSectorDir(p2d)
+ <<std::endl
+ <<"You could try to delete it."<<std::endl;
+ throw e;
+ }
- sector->setNode(p+v3s16(0,4,0), n);
-
- sector->setNode(p+v3s16(-1,4,0), n);
- sector->setNode(p+v3s16(1,4,0), n);
- sector->setNode(p+v3s16(0,4,-1), n);
- sector->setNode(p+v3s16(0,4,1), n);
- sector->setNode(p+v3s16(1,4,1), n);
- sector->setNode(p+v3s16(-1,4,1), n);
- sector->setNode(p+v3s16(-1,4,-1), n);
- sector->setNode(p+v3s16(1,4,-1), n);
-
- sector->setNode(p+v3s16(-1,3,0), n);
- sector->setNode(p+v3s16(1,3,0), n);
- sector->setNode(p+v3s16(0,3,-1), n);
- sector->setNode(p+v3s16(0,3,1), n);
- sector->setNode(p+v3s16(1,3,1), n);
- sector->setNode(p+v3s16(-1,3,1), n);
- sector->setNode(p+v3s16(-1,3,-1), n);
- sector->setNode(p+v3s16(1,3,-1), n);
-
- objects_to_remove.push_back(p);
-
- // Lighting has to be recalculated for this one.
- sector->getBlocksInArea(p_min, p_max,
- lighting_invalidated_blocks);
- }
- }
- else if(d == SECTOR_OBJECT_BUSH_1)
- {
- if(sector->isValidArea(p + v3s16(0,0,0),
- p + v3s16(0,0,0), &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_LEAVES;
- sector->setNode(p+v3s16(0,0,0), n);
-
- objects_to_remove.push_back(p);
- }
- }
- else if(d == SECTOR_OBJECT_RAVINE)
- {
- s16 maxdepth = -20;
- v3s16 p_min = p + v3s16(-6,maxdepth,-6);
- v3s16 p_max = p + v3s16(6,6,6);
- if(sector->isValidArea(p_min, p_max,
- &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_STONE;
- MapNode n2;
- n2.d = CONTENT_AIR;
- s16 depth = maxdepth + (rand()%10);
- s16 z = 0;
- s16 minz = -6 - (-2);
- s16 maxz = 6 -1;
- for(s16 x=-6; x<=6; x++)
- {
- z += -1 + (rand()%3);
- if(z < minz)
- z = minz;
- if(z > maxz)
- z = maxz;
- for(s16 y=depth+(rand()%2); y<=6; y++)
- {
- /*std::cout<<"("<<p2.X<<","<<p2.Y<<","<<p2.Z<<")"
- <<std::endl;*/
- {
- v3s16 p2 = p + v3s16(x,y,z-2);
- if(is_ground_content(sector->getNode(p2).d)
- && !is_mineral(sector->getNode(p2).d))
- sector->setNode(p2, n);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z-1);
- if(is_ground_content(sector->getNode(p2).d)
- && !is_mineral(sector->getNode(p2).d))
- sector->setNode(p2, n2);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z+0);
- if(is_ground_content(sector->getNode(p2).d)
- && !is_mineral(sector->getNode(p2).d))
- sector->setNode(p2, n2);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z+1);
- if(is_ground_content(sector->getNode(p2).d)
- && !is_mineral(sector->getNode(p2).d))
- sector->setNode(p2, n);
- }
+ /*
+ Try to get a block from the sector
+ */
- //if(sector->getNode(p+v3s16(x,y,z+1)).solidness()==2)
- //if(p.Y+y <= sector->getGroundHeight(p2d+v2s16(x,z-2))+0.5)
- }
- }
-
- objects_to_remove.push_back(p);
-
- // Lighting has to be recalculated for this one.
- sector->getBlocksInArea(p_min, p_max,
- lighting_invalidated_blocks);
- }
- }
- else
- {
- dstream<<"ServerMap::emergeBlock(): "
- "Invalid heightmap object"
- <<std::endl;
- }
+ bool does_not_exist = false;
+ bool lighting_expired = false;
+ MapBlock *block = sector->getBlockNoCreateNoEx(block_y);
- }//try
- catch(InvalidPositionException &e)
+ 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)
{
- dstream<<"WARNING: "<<__FUNCTION_NAME
- <<": while inserting object "<<(int)d
- <<" to ("<<p.X<<","<<p.Y<<","<<p.Z<<"):"
- <<" InvalidPositionException.what()="
- <<e.what()<<std::endl;
- // This is not too fatal and seems to happen sometimes.
- assert(0);
+ // 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);
}
- for(core::list<v3s16>::Iterator i = objects_to_remove.begin();
- i != objects_to_remove.end(); i++)
+ if(lighting_expired)
{
- objects->remove(*i);
+ lighting_invalidated_blocks.insert(p, block);
}
- for(core::map<s16, MapBlock*>::Iterator
- i = changed_blocks_sector.getIterator();
- i.atEnd() == false; i++)
+ /*
+ Initially update sunlight
+ */
+
{
- MapBlock *block = i.getNode()->getValue();
+ core::map<v3s16, bool> light_sources;
+ bool black_air_left = false;
+ bool bottom_invalid =
+ block->propagateSunlight(light_sources, true,
+ &black_air_left, true);
+
+ // 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)
+ {
+ lighting_invalidated_blocks[block->getPos()] = block;
+ }
- changed_blocks.insert(block->getPos(), block);
+ if(bottom_invalid)
+ {
+ lighting_invalidated_blocks[block->getPos()] = block;
+ }
}
-
+
return block;
}
return v3s16(p2d.X, y, p2d.Y);
}
-// Debug helpers
-#define ENABLE_SECTOR_SAVING 1
-#define ENABLE_SECTOR_LOADING 1
-#define ENABLE_BLOCK_SAVING 1
-#define ENABLE_BLOCK_LOADING 1
-
void ServerMap::save(bool only_changed)
{
DSTACK(__FUNCTION_NAME);
dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
- saveMasterHeightmap();
+ saveMapMeta();
+ saveChunkMeta();
u32 sector_meta_count = 0;
u32 block_count = 0;
{
ServerMapSector *sector = (ServerMapSector*)i.getNode()->getValue();
assert(sector->getId() == MAPSECTOR_SERVER);
-
- if(ENABLE_SECTOR_SAVING)
+
+ if(sector->differs_from_disk || only_changed == false)
{
- if(sector->differs_from_disk || only_changed == false)
- {
- saveSectorMeta(sector);
- sector_meta_count++;
- }
+ saveSectorMeta(sector);
+ sector_meta_count++;
}
- if(ENABLE_BLOCK_SAVING)
+ core::list<MapBlock*> blocks;
+ sector->getBlocks(blocks);
+ core::list<MapBlock*>::Iterator j;
+ for(j=blocks.begin(); j!=blocks.end(); j++)
{
- core::list<MapBlock*> blocks;
- sector->getBlocks(blocks);
- core::list<MapBlock*>::Iterator j;
- for(j=blocks.begin(); j!=blocks.end(); j++)
+ MapBlock *block = *j;
+ if(block->getChangedFlag() || only_changed == false)
{
- MapBlock *block = *j;
- if(block->getChangedFlag() || only_changed == false)
- {
- saveBlock(block);
- block_count++;
- }
+ saveBlock(block);
+ block_count++;
+
+ /*dstream<<"ServerMap: Written block ("
+ <<block->getPos().X<<","
+ <<block->getPos().Y<<","
+ <<block->getPos().Z<<")"
+ <<std::endl;*/
}
}
}
{
DSTACK(__FUNCTION_NAME);
dstream<<DTIME<<"ServerMap: Loading map..."<<std::endl;
-
- loadMasterHeightmap();
+
+ loadMapMeta();
+ loadChunkMeta();
std::vector<fs::DirListNode> list = fs::GetDirListing(m_savedir+"/sectors/");
JMutexAutoLock lock(m_sector_mutex);
- s32 counter = 0;
- s32 printed_counter = -100000;
- s32 count = list.size();
+ s32 counter = 0;
+ s32 printed_counter = -100000;
+ s32 count = list.size();
+
+ std::vector<fs::DirListNode>::iterator i;
+ for(i=list.begin(); i!=list.end(); i++)
+ {
+ if(counter > printed_counter + 10)
+ {
+ dstream<<DTIME<<counter<<"/"<<count<<std::endl;
+ printed_counter = counter;
+ }
+ counter++;
+
+ MapSector *sector = NULL;
+
+ // We want directories
+ if(i->dir == false)
+ continue;
+ try{
+ sector = loadSectorMeta(i->name);
+ }
+ catch(InvalidFilenameException &e)
+ {
+ // This catches unknown crap in directory
+ }
+
+ std::vector<fs::DirListNode> list2 = fs::GetDirListing
+ (m_savedir+"/sectors/"+i->name);
+ std::vector<fs::DirListNode>::iterator i2;
+ for(i2=list2.begin(); i2!=list2.end(); i2++)
+ {
+ // We want files
+ if(i2->dir)
+ continue;
+ try{
+ loadBlock(i->name, i2->name, sector);
+ }
+ catch(InvalidFilenameException &e)
+ {
+ // This catches unknown crap in directory
+ }
+ }
+ }
+ dstream<<DTIME<<"ServerMap: Map loaded."<<std::endl;
+}
+
+#if 0
+void ServerMap::saveMasterHeightmap()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
+
+ createDir(m_savedir);
+
+ /*std::string fullpath = m_savedir + "/master_heightmap";
+ std::ofstream o(fullpath.c_str(), std::ios_base::binary);
+ if(o.good() == false)
+ throw FileNotGoodException("Cannot open master heightmap");*/
+
+ // Format used for writing
+ //u8 version = SER_FMT_VER_HIGHEST;
+}
+
+void ServerMap::loadMasterHeightmap()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
+
+ /*std::string fullpath = m_savedir + "/master_heightmap";
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if(is.good() == false)
+ throw FileNotGoodException("Cannot open master heightmap");*/
+}
+#endif
+
+void ServerMap::saveMapMeta()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ dstream<<"INFO: ServerMap::saveMapMeta(): "
+ <<"seed="<<m_seed<<", chunksize="<<m_chunksize
+ <<std::endl;
+
+ createDir(m_savedir);
+
+ std::string fullpath = m_savedir + "/map_meta.txt";
+ 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.setS32("chunksize", m_chunksize);
+
+ params.writeLines(os);
+
+ os<<"[end_of_params]\n";
+
+}
+
+void ServerMap::loadMapMeta()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ dstream<<"INFO: ServerMap::loadMapMeta(): Loading chunk metadata"
+ <<std::endl;
- std::vector<fs::DirListNode>::iterator i;
- for(i=list.begin(); i!=list.end(); i++)
+ std::string fullpath = m_savedir + "/map_meta.txt";
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if(is.good() == false)
{
- if(counter > printed_counter + 10)
- {
- dstream<<DTIME<<counter<<"/"<<count<<std::endl;
- printed_counter = counter;
- }
- counter++;
+ dstream<<"ERROR: ServerMap::loadMapMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open chunk metadata");
+ }
- MapSector *sector = NULL;
+ Settings params;
- // We want directories
- if(i->dir == false)
- continue;
- try{
- sector = loadSectorMeta(i->name);
- }
- catch(InvalidFilenameException &e)
- {
- // This catches unknown crap in directory
- }
-
- if(ENABLE_BLOCK_LOADING)
- {
- std::vector<fs::DirListNode> list2 = fs::GetDirListing
- (m_savedir+"/sectors/"+i->name);
- std::vector<fs::DirListNode>::iterator i2;
- for(i2=list2.begin(); i2!=list2.end(); i2++)
- {
- // We want files
- if(i2->dir)
- continue;
- try{
- loadBlock(i->name, i2->name, sector);
- }
- catch(InvalidFilenameException &e)
- {
- // This catches unknown crap in directory
- }
- }
- }
+ 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);
}
- dstream<<DTIME<<"ServerMap: Map loaded."<<std::endl;
+
+ m_seed = params.getU64("seed");
+ m_chunksize = params.getS32("chunksize");
+
+ dstream<<"INFO: ServerMap::loadMapMeta(): "
+ <<"seed="<<m_seed<<", chunksize="<<m_chunksize
+ <<std::endl;
}
-void ServerMap::saveMasterHeightmap()
+void ServerMap::saveChunkMeta()
{
DSTACK(__FUNCTION_NAME);
- createDir(m_savedir);
-
- std::string fullpath = m_savedir + "/master_heightmap";
- std::ofstream o(fullpath.c_str(), std::ios_base::binary);
- if(o.good() == false)
- throw FileNotGoodException("Cannot open master heightmap");
- // Format used for writing
- u8 version = SER_FMT_VER_HIGHEST;
+ u32 count = m_chunks.size();
-#if 0
- SharedBuffer<u8> hmdata = m_heightmap->serialize(version);
- /*
- [0] u8 serialization version
- [1] X master heightmap
- */
- u32 fullsize = 1 + hmdata.getSize();
- SharedBuffer<u8> data(fullsize);
+ dstream<<"INFO: ServerMap::saveChunkMeta(): Saving metadata of "
+ <<count<<" chunks"<<std::endl;
- data[0] = version;
- memcpy(&data[1], *hmdata, hmdata.getSize());
+ createDir(m_savedir);
+
+ std::string fullpath = m_savedir + "/chunk_meta";
+ std::ofstream os(fullpath.c_str(), std::ios_base::binary);
+ if(os.good() == false)
+ {
+ dstream<<"ERROR: ServerMap::saveChunkMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open chunk metadata");
+ }
+
+ u8 version = 0;
+
+ // Write version
+ os.write((char*)&version, 1);
- o.write((const char*)*data, fullsize);
-#endif
+ u8 buf[4];
- m_heightmap->serialize(o, version);
+ // Write count
+ writeU32(buf, count);
+ os.write((char*)buf, 4);
+
+ for(core::map<v2s16, MapChunk*>::Iterator
+ i = m_chunks.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v2s16 p = i.getNode()->getKey();
+ MapChunk *chunk = i.getNode()->getValue();
+ // Write position
+ writeV2S16(buf, p);
+ os.write((char*)buf, 4);
+ // Write chunk data
+ chunk->serialize(os, version);
+ }
}
-void ServerMap::loadMasterHeightmap()
+void ServerMap::loadChunkMeta()
{
DSTACK(__FUNCTION_NAME);
- std::string fullpath = m_savedir + "/master_heightmap";
+
+ dstream<<"INFO: ServerMap::loadChunkMeta(): Loading chunk metadata"
+ <<std::endl;
+
+ std::string fullpath = m_savedir + "/chunk_meta";
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
- throw FileNotGoodException("Cannot open master heightmap");
+ {
+ dstream<<"ERROR: ServerMap::loadChunkMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open chunk metadata");
+ }
+
+ u8 version = 0;
- if(m_heightmap != NULL)
- delete m_heightmap;
-
- m_heightmap = UnlimitedHeightmap::deSerialize(is);
+ // Read version
+ is.read((char*)&version, 1);
+
+ u8 buf[4];
+
+ // Read count
+ is.read((char*)buf, 4);
+ u32 count = readU32(buf);
+
+ dstream<<"INFO: ServerMap::loadChunkMeta(): Loading metadata of "
+ <<count<<" chunks"<<std::endl;
+
+ for(u32 i=0; i<count; i++)
+ {
+ v2s16 p;
+ MapChunk *chunk = new MapChunk();
+ // Read position
+ is.read((char*)buf, 4);
+ p = readV2S16(buf);
+ // Read chunk data
+ chunk->deSerialize(is, version);
+ m_chunks.insert(p, chunk);
+ }
}
void ServerMap::saveSectorMeta(ServerMapSector *sector)
std::string dir = getSectorDir(pos);
createDir(dir);
- std::string fullpath = dir + "/heightmap";
+ std::string fullpath = dir + "/meta";
std::ofstream o(fullpath.c_str(), std::ios_base::binary);
if(o.good() == false)
- throw FileNotGoodException("Cannot open master heightmap");
+ throw FileNotGoodException("Cannot open sector metafile");
sector->serialize(o, version);
v2s16 p2d = getSectorPos(dirname);
std::string dir = m_savedir + "/sectors/" + dirname;
- std::string fullpath = dir + "/heightmap";
+ std::string fullpath = dir + "/meta";
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
- throw FileNotGoodException("Cannot open sector heightmap");
+ throw FileNotGoodException("Cannot open sector metafile");
ServerMapSector *sector = ServerMapSector::deSerialize
- (is, this, p2d, &m_hwrapper, m_sectors);
+ (is, this, p2d, m_sectors);
sector->differs_from_disk = false;
{
return false;
}
-
- if(ENABLE_BLOCK_LOADING)
+
+ /*
+ Load blocks
+ */
+ std::vector<fs::DirListNode> list2 = fs::GetDirListing
+ (m_savedir+"/sectors/"+sectorsubdir);
+ std::vector<fs::DirListNode>::iterator i2;
+ for(i2=list2.begin(); i2!=list2.end(); i2++)
{
- std::vector<fs::DirListNode> list2 = fs::GetDirListing
- (m_savedir+"/sectors/"+sectorsubdir);
- std::vector<fs::DirListNode>::iterator i2;
- for(i2=list2.begin(); i2!=list2.end(); i2++)
+ // We want files
+ if(i2->dir)
+ continue;
+ try{
+ loadBlock(sectorsubdir, i2->name, sector);
+ }
+ catch(InvalidFilenameException &e)
{
- // We want files
- if(i2->dir)
- continue;
- try{
- loadBlock(sectorsubdir, i2->name, sector);
- }
- catch(InvalidFilenameException &e)
- {
- // This catches unknown crap in directory
- }
+ // This catches unknown crap in directory
}
}
return true;
// Gets from master heightmap
void ServerMap::getSectorCorners(v2s16 p2d, s16 *corners)
{
- assert(m_heightmap != NULL);
+ dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
+ //assert(m_heightmap != NULL);
/*
Corner definition:
v2s16(0,0),
v2s16(1,1),
v2s16(0,1),
*/
- corners[0] = m_heightmap->getGroundHeight
+ /*corners[0] = m_heightmap->getGroundHeight
((p2d+v2s16(0,0))*SECTOR_HEIGHTMAP_SPLIT);
corners[1] = m_heightmap->getGroundHeight
((p2d+v2s16(1,0))*SECTOR_HEIGHTMAP_SPLIT);
corners[2] = m_heightmap->getGroundHeight
((p2d+v2s16(1,1))*SECTOR_HEIGHTMAP_SPLIT);
corners[3] = m_heightmap->getGroundHeight
- ((p2d+v2s16(0,1))*SECTOR_HEIGHTMAP_SPLIT);
+ ((p2d+v2s16(0,1))*SECTOR_HEIGHTMAP_SPLIT);*/
}
void ServerMap::PrintInfo(std::ostream &out)
ClientMap::ClientMap(
Client *client,
- JMutex &range_mutex,
- float &viewing_range_nodes,
- bool &viewing_range_all,
+ MapDrawControl &control,
scene::ISceneNode* parent,
scene::ISceneManager* mgr,
s32 id
Map(dout_client),
scene::ISceneNode(parent, mgr, id),
m_client(client),
- mesh(NULL),
- m_range_mutex(range_mutex),
- m_viewing_range_nodes(viewing_range_nodes),
- m_viewing_range_all(viewing_range_all)
+ m_control(control)
{
- mesh_mutex.Init();
+ //mesh_mutex.Init();
/*m_box = core::aabbox3d<f32>(0,0,0,
map->getW()*BS, map->getH()*BS, map->getD()*BS);*/
ClientMap::~ClientMap()
{
- JMutexAutoLock lock(mesh_mutex);
+ /*JMutexAutoLock lock(mesh_mutex);
if(mesh != NULL)
{
mesh->drop();
mesh = NULL;
- }
+ }*/
}
MapSector * ClientMap::emergeSector(v2s16 p2d)
*/
int time1 = time(0);
- //s32 daynight_i = m_client->getDayNightIndex();
u32 daynight_ratio = m_client->getDayNightRatio();
- /*
- Collect all blocks that are in the view range
-
- Should not optimize more here as we want to auto-update
- all changed nodes in viewing range at the next step.
- */
-
- float viewing_range_nodes;
- bool viewing_range_all;
- {
- JMutexAutoLock lock(m_range_mutex);
- viewing_range_nodes = m_viewing_range_nodes;
- viewing_range_all = m_viewing_range_all;
- }
-
m_camera_mutex.Lock();
v3f camera_position = m_camera_position;
v3f camera_direction = m_camera_direction;
camera_position.Y / BS,
camera_position.Z / BS);
- v3s16 box_nodes_d = viewing_range_nodes * v3s16(1,1,1);
+ v3s16 box_nodes_d = m_control.wanted_range * v3s16(1,1,1);
v3s16 p_nodes_min = cam_pos_nodes - box_nodes_d;
v3s16 p_nodes_max = cam_pos_nodes + box_nodes_d;
// For limiting number of mesh updates per frame
u32 mesh_update_count = 0;
+
+ u32 blocks_would_have_drawn = 0;
+ u32 blocks_drawn = 0;
//NOTE: The sectors map should be locked but we're not doing it
// because it'd cause too much delays
int timecheck_counter = 0;
-
core::map<v2s16, MapSector*>::Iterator si;
si = m_sectors.getIterator();
for(; si.atEnd() == false; si++)
timecheck_counter++;
if(timecheck_counter > 50)
{
+ timecheck_counter = 0;
int time2 = time(0);
if(time2 > time1 + 4)
{
MapSector *sector = si.getNode()->getValue();
v2s16 sp = sector->getPos();
- if(viewing_range_all == false)
+ if(m_control.range_all == false)
{
if(sp.X < p_blocks_min.X
|| sp.X > p_blocks_max.X
if not seen on display
*/
- v3s16 blockpos_nodes = block->getPosRelative();
-
- // Block center position
- v3f blockpos(
- ((float)blockpos_nodes.X + MAP_BLOCKSIZE/2) * BS,
- ((float)blockpos_nodes.Y + MAP_BLOCKSIZE/2) * BS,
- ((float)blockpos_nodes.Z + MAP_BLOCKSIZE/2) * BS
- );
-
- // Block position relative to camera
- v3f blockpos_relative = blockpos - camera_position;
-
- // Distance in camera direction (+=front, -=back)
- f32 dforward = blockpos_relative.dotProduct(camera_direction);
-
- // Total distance
- f32 d = blockpos_relative.getLength();
-
- if(viewing_range_all == false)
- {
- // If block is far away, don't draw it
- if(d > viewing_range_nodes * BS)
- // This is nicer when fog is used
- //if((dforward+d)/2 > viewing_range_nodes * BS)
- continue;
- }
-
- // Maximum radius of a block
- f32 block_max_radius = 0.5*1.44*1.44*MAP_BLOCKSIZE*BS;
+ float range = 100000 * BS;
+ if(m_control.range_all == false)
+ range = m_control.wanted_range * BS;
- // If block is (nearly) touching the camera, don't
- // bother validating further (that is, render it anyway)
- if(d > block_max_radius * 1.5)
+ float d = 0.0;
+ if(isBlockInSight(block->getPos(), camera_position,
+ camera_direction, range, &d) == false)
{
- // Cosine of the angle between the camera direction
- // and the block direction (camera_direction is an unit vector)
- f32 cosangle = dforward / d;
-
- // Compensate for the size of the block
- // (as the block has to be shown even if it's a bit off FOV)
- // This is an estimate.
- cosangle += block_max_radius / dforward;
-
- // If block is not in the field of view, skip it
- //if(cosangle < cos(FOV_ANGLE/2))
- if(cosangle < cos(FOV_ANGLE/2. * 4./3.))
- continue;
+ continue;
}
+ // This is ugly
+ /*if(m_control.range_all == false &&
+ d - 0.5*BS*MAP_BLOCKSIZE > range)
+ continue;*/
+
+#if 1
/*
- Draw the faces of the block
+ Update expired mesh (used for day/night change)
*/
-#if 1
+
bool mesh_expired = false;
{
}
f32 faraway = BS*50;
- //f32 faraway = viewing_range_nodes * BS;
+ //f32 faraway = m_control.wanted_range * BS;
/*
This has to be done with the mesh_mutex unlocked
*/
- if(mesh_expired && mesh_update_count < 6
- && (d < faraway || mesh_update_count < 3))
- //if(mesh_expired && mesh_update_count < 4)
+ // 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))*/
{
mesh_update_count++;
continue;
}*/
#endif
+ /*
+ Draw the faces of the block
+ */
{
JMutexAutoLock lock(block->mesh_mutex);
if(mesh == NULL)
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;
+ blocks_drawn++;
u32 c = mesh->getMeshBufferCount();
// 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.
+ */
driver->setMaterial(buf->getMaterial());
driver->drawMeshBuffer(buf);
vertex_count += buf->getVertexCount();
}
} // foreach sectorblocks
}
+
+ m_control.blocks_drawn = blocks_drawn;
+ m_control.blocks_would_have_drawn = blocks_would_have_drawn;
/*dstream<<"renderMap(): is_transparent_pass="<<is_transparent_pass
<<", rendered "<<vertex_count<<" vertices."<<std::endl;*/
}
-v3s16 ClientMap::setTempMod(v3s16 p, NodeMod mod)
+bool ClientMap::setTempMod(v3s16 p, NodeMod mod,
+ core::map<v3s16, MapBlock*> *affected_blocks)
{
+ bool changed = false;
/*
Add it to all blocks touching it
*/
continue;
// Relative position of requested node
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- blockref->setTempMod(relpos, mod);
+ if(blockref->setTempMod(relpos, mod))
+ {
+ 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);
+ }
}
- return getNodeBlockPos(p);
+ return changed;
}
-v3s16 ClientMap::clearTempMod(v3s16 p)
+
+bool ClientMap::clearTempMod(v3s16 p,
+ core::map<v3s16, MapBlock*> *affected_blocks)
{
+ bool changed = false;
v3s16 dirs[7] = {
v3s16(0,0,0), // this
v3s16(0,0,1), // back
continue;
// Relative position of requested node
v3s16 relpos = p - blockpos*MAP_BLOCKSIZE;
- blockref->clearTempMod(relpos);
+ 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);
+ }
}
- return getNodeBlockPos(p);
+ return changed;
}
void ClientMap::PrintInfo(std::ostream &out)
<<std::endl;*/
}
-#if 1
void MapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
{
TimeTaker timer1("emerge", &emerge_time);
}
}
- m_loaded_blocks.insert(p, true);
+ m_loaded_blocks.insert(p, !block_data_inexistent);
}
//dstream<<"emerge done"<<std::endl;
}
-#endif
-
-#if 0
-void MapVoxelManipulator::emerge(VoxelArea a)
-{
- TimeTaker timer1("emerge", &emerge_time);
-
- v3s16 size = a.getExtent();
-
- VoxelArea padded = a;
- padded.pad(m_area.getExtent() / 4);
- addArea(padded);
-
- for(s16 z=0; z<size.Z; z++)
- for(s16 y=0; y<size.Y; y++)
- for(s16 x=0; x<size.X; x++)
- {
- v3s16 p(x,y,z);
- s32 i = m_area.index(a.MinEdge + p);
- // Don't touch nodes that have already been loaded
- if(!(m_flags[i] & VOXELFLAG_NOT_LOADED))
- continue;
- try
- {
- TimeTaker timer1("emerge load", &emerge_load_time);
- MapNode n = m_map->getNode(a.MinEdge + p);
- m_data[i] = n;
- m_flags[i] = 0;
- }
- catch(InvalidPositionException &e)
- {
- m_flags[i] = VOXELFLAG_INEXISTENT;
- }
- }
-}
-#endif
-
/*
- TODO: Add an option to only update eg. water and air nodes.
+ 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.
*/
return;
//TimeTaker timer1("blitBack");
+
+ /*dstream<<"blitBack(): m_loaded_blocks.size()="
+ <<m_loaded_blocks.size()<<std::endl;*/
/*
Initialize block cache
}
}
+ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map):
+ MapVoxelManipulator(map)
+{
+}
+
+ManualMapVoxelManipulator::~ManualMapVoxelManipulator()
+{
+}
+
+void ManualMapVoxelManipulator::emerge(VoxelArea a, s32 caller_id)
+{
+ // Just create the area so that it can be pointed to
+ VoxelManipulator::emerge(a, caller_id);
+}
+
+void ManualMapVoxelManipulator::initialEmerge(
+ v3s16 blockpos_min, v3s16 blockpos_max)
+{
+ TimeTaker timer1("initialEmerge", &emerge_time);
+
+ // 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;
+ }
+
+ 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
+ */
+ 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++)
+ {
+ bool existed = i.getNode()->getValue();
+ if(existed == false)
+ continue;
+ v3s16 p = i.getNode()->getKey();
+ 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);
+ }
+}
+
//END
projects / minetest.git / blobdiff