#include "voxel.h"
#include "porting.h"
#include "mineral.h"
+#include "noise.h"
/*
Map
Map::Map(std::ostream &dout):
m_dout(dout),
- m_camera_position(0,0,0),
- m_camera_direction(0,0,1),
- m_sector_cache(NULL),
- m_hwrapper(this)
+ m_sector_cache(NULL)
{
m_sector_mutex.Init();
- m_camera_mutex.Init();
assert(m_sector_mutex.IsInitialized());
- assert(m_camera_mutex.IsInitialized());
-
- // Get this so that the player can stay on it at first
- //getSector(v2s16(0,0));
}
Map::~Map()
{
/*
- Stop updater thread
- */
- /*updater.setRun(false);
- while(updater.IsRunning())
- sleep_s(1);*/
-
- /*
- Free all MapSectors.
+ Free all MapSectors
*/
core::map<v2s16, MapSector*>::Iterator i = m_sectors.getIterator();
for(; i.atEnd() == false; i++)
}
}
+void Map::addEventReceiver(MapEventReceiver *event_receiver)
+{
+ m_event_receivers.insert(event_receiver, false);
+}
+
+void Map::removeEventReceiver(MapEventReceiver *event_receiver)
+{
+ if(m_event_receivers.find(event_receiver) == NULL)
+ return;
+ m_event_receivers.remove(event_receiver);
+}
+
+void Map::dispatchEvent(MapEditEvent *event)
+{
+ for(core::map<MapEventReceiver*, bool>::Iterator
+ i = m_event_receivers.getIterator();
+ i.atEnd()==false; i++)
+ {
+ MapEventReceiver* event_receiver = i.getNode()->getKey();
+ event_receiver->onMapEditEvent(event);
+ }
+}
+
MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p)
{
if(m_sector_cache != NULL && p == m_sector_cache_p){
return block;
}*/
-f32 Map::getGroundHeight(v2s16 p, bool generate)
-{
- try{
- v2s16 sectorpos = getNodeSectorPos(p);
- MapSector * sref = getSectorNoGenerate(sectorpos);
- v2s16 relpos = p - sectorpos * MAP_BLOCKSIZE;
- f32 y = sref->getGroundHeight(relpos);
- return y;
- }
- catch(InvalidPositionException &e)
- {
- return GROUNDHEIGHT_NOTFOUND_SETVALUE;
- }
-}
-
-void Map::setGroundHeight(v2s16 p, f32 y, bool generate)
-{
- /*m_dout<<DTIME<<"Map::setGroundHeight(("
- <<p.X<<","<<p.Y
- <<"), "<<y<<")"<<std::endl;*/
- v2s16 sectorpos = getNodeSectorPos(p);
- MapSector * sref = getSectorNoGenerate(sectorpos);
- v2s16 relpos = p - sectorpos * MAP_BLOCKSIZE;
- //sref->mutex.Lock();
- sref->setGroundHeight(relpos, y);
- //sref->mutex.Unlock();
-}
-
bool Map::isNodeUnderground(v3s16 p)
{
v3s16 blockpos = getNodeBlockPos(p);
The lighting value of the node should be left as-is after changing
other values. This sets the lighting value to 0.
*/
-/*void Map::nodeAddedUpdate(v3s16 p, u8 lightwas,
- core::map<v3s16, MapBlock*> &modified_blocks)*/
void Map::addNodeAndUpdate(v3s16 p, MapNode n,
core::map<v3s16, MapBlock*> &modified_blocks)
{
/*PrintInfo(m_dout);
- m_dout<<DTIME<<"Map::nodeAddedUpdate(): p=("
+ m_dout<<DTIME<<"Map::addNodeAndUpdate(): p=("
<<p.X<<","<<p.Y<<","<<p.Z<<")"<<std::endl;*/
-
+
/*
From this node to nodes underneath:
If lighting is sunlight (1.0), unlight neighbours and
{
}
- if(n.d != CONTENT_TORCH)
+ /*
+ If the new node doesn't propagate sunlight and there is
+ grass below, change it to mud
+ */
+ if(content_features(n.d).sunlight_propagates == false)
{
- /*
- If there is grass below, change it to mud
- */
try{
MapNode bottomnode = getNode(bottompos);
}
}
+ /*
+ If the new node is mud and it is under sunlight, change it
+ to grass
+ */
+ if(n.d == CONTENT_MUD && node_under_sunlight)
+ {
+ n.d = CONTENT_GRASS;
+ }
+
+ /*
+ Remove all light that has come out of this node
+ */
+
enum LightBank banks[] =
{
LIGHTBANK_DAY,
assert(block != NULL);
modified_blocks.insert(blockpos, block);
- if(isValidPosition(p) == false)
- throw;
+ assert(isValidPosition(p));
// Unlight neighbours of node.
// This means setting light of all consequent dimmer nodes
n.setLight(bank, 0);
}
+
+ /*
+ If node lets sunlight through and is under sunlight, it has
+ sunlight too.
+ */
+ if(node_under_sunlight && content_features(n.d).sunlight_propagates)
+ {
+ n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
+ }
+
+ /*
+ Set the node on the map
+ */
setNode(p, n);
+
+ /*
+ Add intial metadata
+ */
+
+ NodeMetadata *meta_proto = content_features(n.d).initial_metadata;
+ if(meta_proto)
+ {
+ NodeMetadata *meta = meta_proto->clone();
+ setNodeMetadata(p, meta);
+ }
/*
- If node is under sunlight, take all sunlighted nodes under
- it and clear light from them and from where the light has
- been spread.
+ If node is under sunlight and doesn't let sunlight through,
+ take all sunlighted nodes under it and clear light from them
+ and from where the light has been spread.
TODO: This could be optimized by mass-unlighting instead
of looping
*/
- if(node_under_sunlight)
+ if(node_under_sunlight && !content_features(n.d).sunlight_propagates)
{
s16 y = p.Y - 1;
for(;; y--){
if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN)
{
- //m_dout<<DTIME<<"doing"<<std::endl;
unLightNeighbors(LIGHTBANK_DAY,
n2pos, n2.getLight(LIGHTBANK_DAY),
light_sources, modified_blocks);
break;
}
}
-
+
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
/*
Spread light from all nodes that might be capable of doing so
- TODO: Convert to spreadLight
*/
spreadLight(bank, light_sources, modified_blocks);
}
light_sources, modified_blocks);
}
+ /*
+ Remove node metadata
+ */
+
+ removeNodeMetadata(p);
+
/*
Remove the node.
This also clears the lighting.
}
catch(InvalidPositionException &e)
{
- throw;
+ assert(0);
}
}
}
}
-#ifndef SERVER
-void Map::expireMeshes(bool only_daynight_diffed)
+bool Map::addNodeWithEvent(v3s16 p, MapNode n)
{
- TimeTaker timer("expireMeshes()");
+ MapEditEvent event;
+ event.type = MEET_ADDNODE;
+ event.p = p;
+ event.n = n;
- core::map<v2s16, MapSector*>::Iterator si;
- si = m_sectors.getIterator();
- for(; si.atEnd() == false; si++)
- {
- MapSector *sector = si.getNode()->getValue();
+ bool succeeded = true;
+ try{
+ core::map<v3s16, MapBlock*> modified_blocks;
+ addNodeAndUpdate(p, n, modified_blocks);
- core::list< MapBlock * > sectorblocks;
- sector->getBlocks(sectorblocks);
-
- core::list< MapBlock * >::Iterator i;
- for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
+ // Copy modified_blocks to event
+ for(core::map<v3s16, MapBlock*>::Iterator
+ i = modified_blocks.getIterator();
+ i.atEnd()==false; i++)
{
- MapBlock *block = *i;
-
- if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
- {
- continue;
- }
-
- {
- JMutexAutoLock lock(block->mesh_mutex);
- if(block->mesh != NULL)
- {
- /*block->mesh->drop();
- block->mesh = NULL;*/
- block->setMeshExpired(true);
- }
- }
+ event.modified_blocks.insert(i.getNode()->getKey(), false);
}
}
+ catch(InvalidPositionException &e){
+ succeeded = false;
+ }
+
+ dispatchEvent(&event);
+
+ return succeeded;
}
-void Map::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
+bool Map::removeNodeWithEvent(v3s16 p)
{
- assert(mapType() == MAPTYPE_CLIENT);
+ MapEditEvent event;
+ event.type = MEET_REMOVENODE;
+ event.p = p;
+ bool succeeded = true;
try{
- v3s16 p = blockpos + v3s16(0,0,0);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
- }
- catch(InvalidPositionException &e){}
- // Leading edge
- try{
- v3s16 p = blockpos + v3s16(-1,0,0);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
- }
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,-1,0);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
- }
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,0,-1);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
- }
- catch(InvalidPositionException &e){}
- /*// Trailing edge
- try{
- v3s16 p = blockpos + v3s16(1,0,0);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
- }
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,1,0);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
+ core::map<v3s16, MapBlock*> modified_blocks;
+ removeNodeAndUpdate(p, modified_blocks);
+
+ // Copy modified_blocks to event
+ for(core::map<v3s16, MapBlock*>::Iterator
+ i = modified_blocks.getIterator();
+ i.atEnd()==false; i++)
+ {
+ event.modified_blocks.insert(i.getNode()->getKey(), false);
+ }
}
- catch(InvalidPositionException &e){}
- try{
- v3s16 p = blockpos + v3s16(0,0,1);
- MapBlock *b = getBlockNoCreate(p);
- b->updateMesh(daynight_ratio);
+ catch(InvalidPositionException &e){
+ succeeded = false;
}
- catch(InvalidPositionException &e){}*/
-}
-#endif
+ dispatchEvent(&event);
+
+ return succeeded;
+}
bool Map::dayNightDiffed(v3s16 blockpos)
{
u32 loopcount = 0;
u32 initial_size = m_transforming_liquid.size();
-
- //dstream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;
+
+ /*if(initial_size != 0)
+ dstream<<"transformLiquids(): initial_size="<<initial_size<<std::endl;*/
while(m_transforming_liquid.size() != 0)
{
//dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
}
+NodeMetadata* Map::getNodeMetadata(v3s16 p)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+ <<std::endl;
+ return NULL;
+ }
+ NodeMetadata *meta = block->m_node_metadata.get(p_rel);
+ return meta;
+}
+
+void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_metadata.set(p_rel, meta);
+}
+
+void Map::removeNodeMetadata(v3s16 p)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_metadata.remove(p_rel);
+}
+
/*
ServerMap
*/
-ServerMap::ServerMap(std::string savedir, HMParams hmp, MapParams mp):
+ServerMap::ServerMap(std::string savedir):
Map(dout_server),
- m_heightmap(NULL)
+ m_seed(0)
{
//m_chunksize = 64;
- //m_chunksize = 16;
- m_chunksize = 8;
+ //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
*/
{
- dstream<<"Generating map point attribute lists"<<std::endl;
-
- PointAttributeList *list_baseheight = m_padb.getList("hm_baseheight");
- PointAttributeList *list_randmax = m_padb.getList("hm_randmax");
- PointAttributeList *list_randfactor = m_padb.getList("hm_randfactor");
- //PointAttributeList *list_plants_amount = m_padb.getList("plants_amount");
- //PointAttributeList *list_caves_amount = m_padb.getList("caves_amount");
-
-#if 0
- /*
- NOTE: BEWARE: Too big amount of these will make map generation
- slow. Especially those that are read by every block emerge.
-
- Fetch times:
- 1000 points: 2-3ms
- 5000 points: 15ms
- 15000 points: 40ms
- */
-
- for(u32 i=0; i<500; i++)
- {
- /*u32 lim = MAP_GENERATION_LIMIT;
- if(i < 400)
- lim = 2000;*/
-
- u32 lim = 500 + MAP_GENERATION_LIMIT * i / 500;
-
- v3s16 p(
- -lim + myrand()%(lim*2),
- 0,
- -lim + myrand()%(lim*2)
- );
- /*float plants_amount = (float)(myrand()%1050) / 1000.0;
- plants_amount = pow(plants_amount, 5);
- list_plants_amount->addPoint(p, Attribute(plants_amount));*/
-
- float plants_amount = 0;
- if(myrand()%4 == 0)
- {
- plants_amount = 1.5;
- }
- else if(myrand()%4 == 0)
- {
- plants_amount = 0.5;
- }
- else if(myrand()%2 == 0)
- {
- plants_amount = 0.03;
- }
- else
- {
- plants_amount = 0.0;
- }
-
-
- list_plants_amount->addPoint(p, Attribute(plants_amount));
- }
-
- for(u32 i=0; i<500; i++)
- {
- /*u32 lim = MAP_GENERATION_LIMIT;
- if(i < 400)
- lim = 2000;*/
-
- u32 lim = 500 + MAP_GENERATION_LIMIT * i / 500;
-
- v3s16 p(
- -lim + myrand()%(lim*2),
- 0,
- -lim + myrand()%(lim*2)
- );
-
- float caves_amount = 0;
- if(myrand()%5 == 0)
- {
- caves_amount = 1.0;
- }
- else if(myrand()%3 == 0)
- {
- caves_amount = 0.3;
- }
- else
- {
- caves_amount = 0.05;
- }
-
- list_caves_amount->addPoint(p, Attribute(caves_amount));
- }
-
- for(u32 i=0; i<500; i++)
- {
- /*u32 lim = MAP_GENERATION_LIMIT;
- if(i < 400)
- lim = 2000;*/
-
- u32 lim = 500 + MAP_GENERATION_LIMIT * i / 500;
-
- v3s16 p(
- -lim + (myrand()%(lim*2)),
- 0,
- -lim + (myrand()%(lim*2))
- );
-
- /*s32 bh_i = (myrand()%200) - 50;
- float baseheight = (float)bh_i;
-
- float m = 100.;
- float e = 3.;
- float randmax = (float)(myrand()%(int)(10.*pow(m, 1./e)))/10.;
- randmax = pow(randmax, e);
-
- //float randmax = (float)(myrand()%60);
- float randfactor = (float)(myrand()%450) / 1000.0 + 0.4;*/
-
- float baseheight = 0;
- float randmax = 0;
- float randfactor = 0;
-
- /*if(myrand()%5 == 0)
- {
- baseheight = 100;
- randmax = 50;
- randfactor = 0.63;
- }
- else if(myrand()%6 == 0)
- {
- baseheight = 200;
- randmax = 100;
- randfactor = 0.66;
- }
- else if(myrand()%4 == 0)
- {
- baseheight = -3;
- randmax = 30;
- randfactor = 0.7;
- }
- else if(myrand()%3 == 0)
- {
- baseheight = 0;
- randmax = 30;
- randfactor = 0.63;
- }
- else
- {
- baseheight = -3;
- randmax = 20;
- randfactor = 0.5;
- }*/
-
- if(myrand()%3 < 2)
- {
- baseheight = 10;
- randmax = 30;
- randfactor = 0.7;
- }
- else
- {
- baseheight = 0;
- randmax = 15;
- randfactor = 0.63;
- }
-
- list_baseheight->addPoint(p, Attribute(baseheight));
- list_randmax->addPoint(p, Attribute(randmax));
- list_randfactor->addPoint(p, Attribute(randfactor));
- }
-#endif
-
- // Add only one entry
- list_baseheight->addPoint(v3s16(0,0,0), Attribute(-4));
- list_randmax->addPoint(v3s16(0,0,0), Attribute(22));
- //list_randmax->addPoint(v3s16(0,0,0), Attribute(0));
- list_randfactor->addPoint(v3s16(0,0,0), Attribute(0.45));
-
- // Easy spawn point
- /*list_baseheight->addPoint(v3s16(0,0,0), Attribute(0));
- list_randmax->addPoint(v3s16(0,0,0), Attribute(10));
- list_randfactor->addPoint(v3s16(0,0,0), Attribute(0.65));*/
}
/*
}
else
{
- // Load master heightmap
- loadMasterHeightmap();
+ // Load map metadata (seed, chunksize)
+ loadMapMeta();
- // Load sector (0,0) and throw and exception on fail
+ // 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)");
+ throw LoadError("Failed to load sector (0,0)");*/
- dstream<<DTIME<<"Server: Successfully loaded master "
- "heightmap and sector (0,0) from "<<savedir<<
+ /*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;
}
catch(std::exception &e)
{
- dstream<<DTIME<<"Server: Failed to load map from "<<savedir
+ dstream<<DTIME<<"WARNING: 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;
+ dstream<<"Please remove the map or fix it."<<std::endl;
+ dstream<<"WARNING: Map saving will be disabled."<<std::endl;
}
- dstream<<DTIME<<"Initializing new map."<<std::endl;
-
- // Create master heightmap
- m_heightmap = new UnlimitedHeightmap
- (32, &m_padb);
-
- // Set map parameters
- m_params = mp;
+ dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
// Create zero sector
emergeSector(v2s16(0,0));
<<", exception: "<<e.what()<<std::endl;
}
- if(m_heightmap != NULL)
- delete m_heightmap;
-
/*
Free all MapChunks
*/
}
/*
- Some helper functions
+ Some helper functions for the map generator
*/
s16 find_ground_level(VoxelManipulator &vmanip, v2s16 p2d)
return y_nodes_min;
}
-void make_tree(VoxelManipulator &vmanip, v3s16 p0)
+s16 find_ground_level_clever(VoxelManipulator &vmanip, v2s16 p2d)
{
- MapNode treenode(CONTENT_TREE);
- MapNode leavesnode(CONTENT_LEAVES);
-
- s16 trunk_h = myrand_range(2, 6);
+ 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++)
{
p1.Y -= 1;
VoxelArea leaves_a(v3s16(-2,-2,-2), v3s16(2,2,2));
- SharedPtr<u8> leaves_d(new u8[leaves_a.getVolume()]);
+ //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;
}
}
+/*
+ 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);
+}
+
+#define AVERAGE_MUD_AMOUNT 4
+
+double base_rock_level_2d(u64 seed, v2s16 p)
+{
+ // The base ground level
+ double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT
+ + 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)
+ 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)
TimeTaker timer("generateChunkRaw()");
- // The distance how far into the neighbors the generator is allowed to go
+ // 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;
+ //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 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;
);
// 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_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
*/
}
}
}
-
+
/*
Now we have a big empty area.
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
*/
// Ground height at this point
float surface_y_f = 0.0;
- /*
- A hack to get the ground height from the sector.
- Do this better.
- */
+
+ // Use perlin noise for ground height
+ surface_y_f = base_rock_level_2d(m_seed, p2d);
+
+ /*// Experimental stuff
{
- v2s16 sectorpos = getContainerPos(p2d, MAP_BLOCKSIZE);
- v2s16 sector_relpos = p2d - sectorpos*MAP_BLOCKSIZE;
- MapSector *sector = getSectorNoGenerate(sectorpos);
- assert(sector);
- float h = sector->getGroundHeight(sector_relpos);
- if(h > GROUNDHEIGHT_VALID_MINVALUE)
- surface_y_f = h;
- else
- dstream<<"WARNING: "<<__FUNCTION_NAME
- <<": sector->getGroundHeight returned bad height"<<std::endl;
- }
+ 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
/*
Randomize some parameters
*/
-
- // 0-100
- // Usually little, sometimes huge
- //u32 stone_obstacle_amount = myrand_range(0, myrand_range(0, 100));
- u32 stone_obstacle_amount = myrand_range(0, myrand_range(20, 100));
+
+ 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
- // This is set during the next operation.
- // 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;
-
{
// 8ms @cs=8
//TimeTaker timer1("stone obstacles");
Add some random stone obstacles
*/
- for(u32 ri=0; ri<stone_obstacle_amount/3; ri++)
- //for(u32 ri=0; ri<7; ri++)
- //if(0)
+ 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, 25);
- s16 maxheight_randomized = myrand_range(0, stone_obstacle_amount/3);
+ 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;
- // The size of these could actually be m_chunksize*MAP_BLOCKSIZE*2
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(0, sectorpos_base_size*MAP_BLOCKSIZE-1),
- myrand_range(0, sectorpos_base_size*MAP_BLOCKSIZE-1)
+ 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 = 10;
+ 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++)
}
// Add mud
count = 0;
- for(; y<=y_nodes_max; y++)
+ for(; y<=y_nodes_max - min_head_space; y++)
{
MapNode &n = vmanip.m_data[i];
n.d = CONTENT_MUD;
/*
Make dungeons
*/
- u32 dungeons_count = relative_volume / 200000;
- u32 bruises_count = relative_volume * stone_surface_max_y / 15000000;
+ 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 = 1;
- s16 max_tunnel_diameter = 5;
- u16 tunnel_routepoints = 10;
+ 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(8, 20);
- tunnel_routepoints = 7;
+ 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
of -= v3s16(1,0,1) * more;
s16 route_y_min = 0;
- //s16 route_y_max = ar.Y-1;
- s16 route_y_max = stone_surface_max_y - of.Y;
+ // 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;
+ //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_y_min, route_y_max))+0.5,
+ (float)(myrand_range(route_start_y_min, route_start_y_max))+0.5,
(float)(myrand()%ar.Z)+0.5
);
for(u16 j=0; j<tunnel_routepoints; j++)
{
- v3s16 maxlen(20, 10, 20);
-
+ // 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(60,60,60);
+ 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 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;
rp.Z = ar.Z-1;
vec = rp - orp;
- // Randomize size
- s16 min_d = min_tunnel_diameter;
- s16 max_d = max_tunnel_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;
s16 d1 = d0 + rs - 1;
for(s16 z0=d0; z0<=d1; z0++)
{
- s16 si = rs - abs(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 = abs(x0)>abs(z0)?abs(x0):abs(z0);
- s16 si2 = rs - maxabsxz;
+ 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; y0<=si2-1; y0++)
+ for(s16 y0=-si2+1+2; y0<=si2-1; y0++)
{
s16 z = cp.Z + z0;
s16 y = cp.Y + y0;
// 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;
+ }
}
}
}
/*
Make ore veins
*/
- for(u32 jj=0; jj<relative_volume/524; jj++)
+ for(u32 jj=0; jj<relative_volume/1000; jj++)
{
s16 max_vein_diameter = 3;
);
// Randomize mineral
- u8 mineral = myrand_range(1, MINERAL_COUNT-1);
+ u8 mineral;
+ if(myrand()%3 != 0)
+ mineral = MINERAL_COAL;
+ else
+ mineral = MINERAL_IRON;
/*
Generate some vein starting from orp
);
v3f vec = rp - orp;*/
- v3s16 maxlen(10, 10, 10);
+ v3s16 maxlen(5, 5, 5);
v3f vec(
(float)(myrand()%(maxlen.X*2))-(float)maxlen.X,
(float)(myrand()%(maxlen.Y*2))-(float)maxlen.Y,
// 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(vmanip, p2d);
+ s16 surface_y = find_ground_level_clever(vmanip, p2d);
/*
If topmost node is grass, change it to mud.
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++;
- if(mudcount >= 3)
- break;
-
+
vmanip.m_area.add_y(em, i, 1);
}
}
}//timer1
{
- // 179ms @cs=8
- //TimeTaker timer1("flow mud");
+ // 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<4; k++)
+ for(s16 k=0; k<3; k++)
{
- for(s16 x=0-max_spread_amount+1;
- x<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ for(s16 x=mudflow_minpos;
+ x<=mudflow_maxpos;
x++)
- for(s16 z=0-max_spread_amount+1;
- z<sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1;
+ 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;
- // Go to ground level
- for(y=y_nodes_max; y>=y_nodes_min; y--)
+ s16 y=y_nodes_max;
+
+ for(;; y--)
{
- MapNode &n = vmanip.m_data[i];
- //if(n.d != CONTENT_AIR)
- if(content_walkable(n.d))
+ 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;
-
- vmanip.m_area.add_y(em, i, -1);
- }
- // If not mud, do nothing to it
- MapNode *n = &vmanip.m_data[i];
- if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
- continue;
+ /*// If not mud, do nothing to it
+ MapNode *n = &vmanip.m_data[i];
+ if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS)
+ continue;*/
- // Make it exactly mud
- n->d = CONTENT_MUD;
+ /*
+ 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;
+ }
- v3s16 dirs4[4] = {
- v3s16(0,0,1), // back
- v3s16(1,0,0), // right
- v3s16(0,0,-1), // front
- v3s16(-1,0,0), // left
- };
+ // Make it exactly mud
+ n->d = CONTENT_MUD;
+
+ /*s16 recurse_count = 0;
+ mudflow_recurse:*/
- // Drop mud on side
-
- for(u32 di=0; di<4; di++)
- {
- v3s16 dirp = dirs4[di];
- u32 i2 = i;
- // Check that side is air
- vmanip.m_area.add_p(em, i2, dirp);
- 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);
- n2 = &vmanip.m_data[i2];
- if(content_walkable(n2->d))
+ 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;
- // Loop further down until not air
- do{
+ }
+
+ // 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];
- }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);
-
- #if 0
- // Switch mud and other and change mud source to air
- //MapNode tempnode = *n2;
- *n2 = *n;
- //*n = tempnode;
- // Force old mud position to be air
- n->d = CONTENT_AIR;
- #endif
-
- // Done
- break;
+ 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;
+ }
}
}
*/
{
v3s16 em = vmanip.m_area.getExtent();
- s16 y_start = WATER_LEVEL;
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
- */
+
+ /*// 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];
if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE
&& n->d != CONTENT_WATER)
{
- /*
- Add bottom one to transforming liquid queue
- */
+ /*// 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;
}
- n->d = CONTENT_WATERSOURCE;
- n->setLight(LIGHTBANK_DAY, light);
+ // 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);*/
+ // 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);
} // Aging loop
{
- // 1ms @cs=8
- //TimeTaker timer1("plant trees");
+ //TimeTaker timer1("convert mud to sand");
/*
- Plant some trees
+ 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++)
{
- u32 tree_max = relative_area / 60;
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
- u32 count = myrand_range(0, tree_max);
- for(u32 i=0; i<count; i++)
+ // 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;
+
{
- 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);
+ 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
-
{
- // 19ms @cs=8
- //TimeTaker timer1("grow grass");
+ // 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;
+ // Don't make a tree so high that it doesn't fit
+ if(y > y_nodes_max - 6)
+ 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
}//timer1
/*
- Handle lighting
+ Initial lighting (sunlight)
*/
core::map<v3s16, bool> light_sources;
{
// 750ms @cs=8, can't optimize more
- //TimeTaker timer1("initial lighting");
+ TimeTaker timer1("initial lighting");
+
+#if 0
+ /*
+ Go through the edges and add all nodes that have light to light_sources
+ */
+
+ // 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);
+
+ {
+ 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
+
+#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
/*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;
+ /*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
}
}
}
-
+
n->setLight(LIGHTBANK_DAY, light);
n->setLight(LIGHTBANK_NIGHT, 0);
}
}
}
+#endif
+
+#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
//TimeTaker timer("generateChunkRaw() blitBackAll");
vmanip.blitBackAll(&changed_blocks);
}
+
/*
Update day/night difference cache of the MapBlocks
*/
}
/*
- Set central chunk non-volatile and return it
+ Set central chunk non-volatile
*/
MapChunk *chunk = getChunk(chunkpos);
assert(chunk);
// Set non-volatile
//chunk->setIsVolatile(false);
chunk->setGenLevel(GENERATED_FULLY);
- // Return it
+
+ /*
+ Save changed parts of map
+ */
+ save(true);
+
+ /*
+ Return central chunk (which was requested)
+ */
return chunk;
}
return sector;
}
- /*
- If there is no master heightmap, throw.
- */
- if(m_heightmap == NULL)
- {
- throw InvalidPositionException("createSector(): no heightmap");
- }
-
/*
Do not create over-limit
*/
Generate blank sector
*/
- // Number of heightmaps in sector in each direction
- u16 hm_split = SECTOR_HEIGHTMAP_SPLIT;
-
- // Heightmap side width
- s16 hm_d = MAP_BLOCKSIZE / hm_split;
-
- sector = new ServerMapSector(this, p2d, hm_split);
+ sector = new ServerMapSector(this, p2d);
// Sector position on map in nodes
v2s16 nodepos2d = p2d * MAP_BLOCKSIZE;
- /*dstream<<"Generating sector ("<<p2d.X<<","<<p2d.Y<<")"
- " heightmaps and objects"<<std::endl;*/
-
- /*
- Generate sector heightmap
- */
-
- 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),
- };*/
-
- // Loop through sub-heightmaps
- for(s16 y=0; y<hm_split; y++)
- for(s16 x=0; x<hm_split; x++)
- {
- 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)),
- };
-
- /*dstream<<"p_in_sector=("<<p_in_sector.X<<","<<p_in_sector.Y<<")"
- <<" mhm_p=("<<mhm_p.X<<","<<mhm_p.Y<<")"
- <<std::endl;*/
-
- FixedHeightmap *hm = new FixedHeightmap(&m_hwrapper,
- mhm_p, hm_d);
- sector->setHeightmap(p_in_sector, hm);
-
- //hm->generateContinued(1.0, 0.5, corners);
- hm->generateContinued(0.5, 0.5, corners);
-
- //hm->print();
- }
-
- // Add dummy objects
- core::map<v3s16, u8> *objects = new core::map<v3s16, u8>;
- sector->setObjects(objects);
-
/*
Insert to container
*/
/*
generateChunk should have generated the sector
*/
- assert(0);
+ //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
*/
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
+ v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
/*
Do not generate over-limit
block->unDummify();
}
- /*u8 water_material = CONTENT_WATER;
- if(g_settings.getBool("endless_water"))
- water_material = CONTENT_WATERSOURCE;*/
u8 water_material = CONTENT_WATERSOURCE;
s32 lowest_ground_y = 32767;
s32 highest_ground_y = -32768;
- // DEBUG
- //sector->printHeightmaps();
-
for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
//dstream<<"generateBlock: 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 = 0;
+
+ s16 surface_y = base_rock_level_2d(m_seed, p2d_nodes+v2s16(x0,z0))
+ + AVERAGE_MUD_AMOUNT;
- 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;
+ s32 surface_depth = AVERAGE_MUD_AMOUNT;
- 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;
/*
Add coal
*/
- u16 coal_amount = 30.0 * g_settings.getFloat("coal_amount");
+ u16 coal_amount = 30;
u16 coal_rareness = 60 / coal_amount;
if(coal_rareness == 0)
coal_rareness = 1;
Add iron
*/
//TODO: change to iron_amount or whatever
- u16 iron_amount = 30.0 * g_settings.getFloat("coal_amount");
+ u16 iron_amount = 15;
u16 iron_rareness = 60 / iron_amount;
if(iron_rareness == 0)
iron_rareness = 1;
//if(!is_ground_content(block->getNode(cp).d))
if(1)
{
- RatObject *obj = new RatObject(NULL, -1, intToFloat(cp));
+ RatObject *obj = new RatObject(NULL, -1, intToFloat(cp, BS));
block->addObject(obj);
}
}
*/
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);
+
/*
- Check if any sector's objects can be placed now.
- If so, place 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++)
- {
- v3s16 p = i.getNode()->getKey();
- v2s16 p2d(p.X,p.Z);
- u8 d = i.getNode()->getValue();
-
- // Ground level point (user for stuff that is on ground)
- v3s16 gp = p;
- bool ground_found = true;
-
- // Search real ground level
- try{
- for(;;)
- {
- MapNode n = sector->getNode(gp);
-
- // If not air, go one up and continue to placing the tree
- if(n.d != CONTENT_AIR)
- {
- gp += v3s16(0,1,0);
- break;
- }
-
- // If air, go one down
- gp += v3s16(0,-1,0);
- }
- }catch(InvalidPositionException &e)
- {
- // Ground not found.
- ground_found = false;
- // This is most close to ground
- gp += v3s16(0,1,0);
- }
-
- try
- {
-
- 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)
- {
- if(ground_found == false)
- continue;
-
- v3s16 p_min = gp + v3s16(-1,0,-1);
- v3s16 p_max = gp + v3s16(1,5,1);
- if(sector->isValidArea(p_min, p_max,
- &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_TREE;
- sector->setNode(gp+v3s16(0,0,0), n);
- sector->setNode(gp+v3s16(0,1,0), n);
- sector->setNode(gp+v3s16(0,2,0), n);
- sector->setNode(gp+v3s16(0,3,0), n);
-
- n.d = CONTENT_LEAVES;
-
- if(myrand()%4!=0) sector->setNode(gp+v3s16(0,5,0), n);
-
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,0), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,0), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(0,5,-1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(0,5,1), n);
- /*if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,5,-1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(1,5,-1), n);*/
-
- sector->setNode(gp+v3s16(0,4,0), n);
-
- sector->setNode(gp+v3s16(-1,4,0), n);
- sector->setNode(gp+v3s16(1,4,0), n);
- sector->setNode(gp+v3s16(0,4,-1), n);
- sector->setNode(gp+v3s16(0,4,1), n);
- sector->setNode(gp+v3s16(1,4,1), n);
- sector->setNode(gp+v3s16(-1,4,1), n);
- sector->setNode(gp+v3s16(-1,4,-1), n);
- sector->setNode(gp+v3s16(1,4,-1), n);
-
- sector->setNode(gp+v3s16(-1,3,0), n);
- sector->setNode(gp+v3s16(1,3,0), n);
- sector->setNode(gp+v3s16(0,3,-1), n);
- sector->setNode(gp+v3s16(0,3,1), n);
- sector->setNode(gp+v3s16(1,3,1), n);
- sector->setNode(gp+v3s16(-1,3,1), n);
- sector->setNode(gp+v3s16(-1,3,-1), n);
- sector->setNode(gp+v3s16(1,3,-1), n);
-
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,0), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,0), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(0,2,-1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(0,2,1), n);
- /*if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(-1,2,-1), n);
- if(myrand()%3!=0) sector->setNode(gp+v3s16(1,2,-1), n);*/
-
- // Objects are identified by wanted position
- 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(ground_found == false)
- continue;
-
- if(sector->isValidArea(gp + v3s16(0,0,0),
- gp + v3s16(0,0,0), &changed_blocks_sector))
- {
- MapNode n;
- n.d = CONTENT_LEAVES;
- sector->setNode(gp+v3s16(0,0,0), n);
-
- // Objects are identified by wanted position
- 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 + (myrand()%10);
- s16 z = 0;
- s16 minz = -6 - (-2);
- s16 maxz = 6 -1;
- for(s16 x=-6; x<=6; x++)
- {
- z += -1 + (myrand()%3);
- if(z < minz)
- z = minz;
- if(z > maxz)
- z = maxz;
- for(s16 y=depth+(myrand()%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))
- if(content_features(sector->getNode(p2).d).walkable)
- sector->setNode(p2, n);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z-1);
- if(content_features(sector->getNode(p2).d).walkable)
- sector->setNode(p2, n2);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z+0);
- if(content_features(sector->getNode(p2).d).walkable)
- sector->setNode(p2, n2);
- }
- {
- v3s16 p2 = p + v3s16(x,y,z+1);
- if(content_features(sector->getNode(p2).d).walkable)
- sector->setNode(p2, n);
- }
-
- //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::generateBlock(): "
- "Invalid heightmap object"
- <<std::endl;
- }
-
- }//try
- catch(InvalidPositionException &e)
- {
- 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);
- }
- }
-
- for(core::list<v3s16>::Iterator i = objects_to_remove.begin();
- i != objects_to_remove.end(); i++)
- {
- objects->remove(*i);
- }
-
- /*
- Translate sector's changed blocks to global changed blocks
+ Do not create over-limit
*/
-
- for(core::map<s16, MapBlock*>::Iterator
- i = changed_blocks_sector.getIterator();
- i.atEnd() == false; i++)
- {
- MapBlock *block = i.getNode()->getValue();
-
- changed_blocks.insert(block->getPos(), block);
- }
-
- block->setLightingExpired(true);
-
-#if 0
- /*
- Debug information
- */
- 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);
+ if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+ throw InvalidPositionException("createBlock(): pos. over limit");
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
sector = (ServerMapSector*)createSector(p2d);
assert(sector->getId() == MAPSECTOR_SERVER);
}
- /*catch(InvalidPositionException &e)
+ catch(InvalidPositionException &e)
{
dstream<<"createBlock: createSector() failed"<<std::endl;
throw e;
- }*/
- catch(std::exception &e)
+ }
+ /*
+ NOTE: This should not be done, or at least the exception
+ should not be passed on as std::exception, because it
+ won't be catched at all.
+ */
+ /*catch(std::exception &e)
{
dstream<<"createBlock: createSector() failed: "
<<e.what()<<std::endl;
throw e;
- }
+ }*/
/*
Try to get a block from the sector
__FUNCTION_NAME,
p.X, p.Y, p.Z, only_from_disk);
+ /*
+ Do not generate over-limit
+ */
+ if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+ throw InvalidPositionException("emergeBlock(): pos. over limit");
+
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
/*
This will create or load a sector if not found in memory.
If block exists on disk, it will be loaded.
-
- NOTE: On old save formats, this will be slow, as it generates
- lighting on blocks for them.
*/
ServerMapSector *sector;
try{
sector = (ServerMapSector*)emergeSector(p2d, changed_blocks);
assert(sector->getId() == MAPSECTOR_SERVER);
}
- catch(std::exception &e)
+ catch(InvalidPositionException &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;
+ }
+ catch(VersionMismatchException &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;
}
+ /*
+ NOTE: This should not be done, or at least the exception
+ should not be passed on as std::exception, because it
+ won't be catched at all.
+ */
+ /*catch(std::exception &e)
+ {
+ dstream<<"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;
+ }*/
/*
Try to get a block from the sector
}
}
+ return block;
+}
+
+s16 ServerMap::findGroundLevel(v2s16 p2d)
+{
/*
- Debug mode operation
+ Uh, just do something random...
*/
- bool haxmode = g_settings.getBool("haxmode");
- if(haxmode)
+ // Find existing map from top to down
+ s16 max=63;
+ s16 min=-64;
+ v3s16 p(p2d.X, max, p2d.Y);
+ for(; p.Y>min; p.Y--)
+ {
+ MapNode n = getNodeNoEx(p);
+ if(n.d != CONTENT_IGNORE)
+ break;
+ }
+ if(p.Y == min)
+ goto plan_b;
+ // If this node is not air, go to plan b
+ if(getNodeNoEx(p).d != CONTENT_AIR)
+ goto plan_b;
+ // Search existing walkable and return it
+ for(; p.Y>min; p.Y--)
{
- // Don't calculate lighting at all
- //lighting_invalidated_blocks.clear();
+ MapNode n = getNodeNoEx(p);
+ if(content_walkable(n.d) && n.d != CONTENT_IGNORE)
+ return p.Y;
}
-
- return block;
+ // Move to plan b
+plan_b:
+ /*
+ Plan B: Get from map generator perlin noise function
+ */
+ double level = base_rock_level_2d(m_seed, p2d);
+ return (s16)level;
}
void ServerMap::createDir(std::string path)
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/");
// 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++)
{
- 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)
{
- // We want files
- if(i2->dir)
- continue;
- try{
- loadBlock(i->name, i2->name, sector);
- }
- catch(InvalidFilenameException &e)
- {
- // This catches unknown crap in directory
- }
+ // 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::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");
+ throw FileNotGoodException("Cannot open master heightmap");*/
// Format used for writing
- u8 version = SER_FMT_VER_HIGHEST;
-
-#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);
+ //u8 version = SER_FMT_VER_HIGHEST;
+}
- data[0] = version;
- memcpy(&data[1], *hmdata, hmdata.getSize());
+void ServerMap::loadMasterHeightmap()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
- o.write((const char*)*data, fullsize);
+ /*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";
- m_heightmap->serialize(o, version);
}
-void ServerMap::loadMasterHeightmap()
+void ServerMap::loadMapMeta()
{
DSTACK(__FUNCTION_NAME);
- std::string fullpath = m_savedir + "/master_heightmap";
+
+ dstream<<"INFO: ServerMap::loadMapMeta(): Loading chunk metadata"
+ <<std::endl;
+
+ std::string fullpath = m_savedir + "/map_meta.txt";
std::ifstream is(fullpath.c_str(), std::ios_base::binary);
if(is.good() == false)
- throw FileNotGoodException("Cannot open master heightmap");
+ {
+ dstream<<"ERROR: ServerMap::loadMapMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open chunk metadata");
+ }
+
+ Settings params;
+
+ for(;;)
+ {
+ if(is.eof())
+ throw SerializationError
+ ("ServerMap::loadMapMeta(): [end_of_params] not found");
+ std::string line;
+ std::getline(is, line);
+ std::string trimmedline = trim(line);
+ if(trimmedline == "[end_of_params]")
+ break;
+ params.parseConfigLine(line);
+ }
+
+ m_seed = params.getU64("seed");
+ m_chunksize = params.getS32("chunksize");
+
+ dstream<<"INFO: ServerMap::loadMapMeta(): "
+ <<"seed="<<m_seed<<", chunksize="<<m_chunksize
+ <<std::endl;
+}
+
+void ServerMap::saveChunkMeta()
+{
+ DSTACK(__FUNCTION_NAME);
- if(m_heightmap != NULL)
- delete m_heightmap;
-
- m_heightmap = UnlimitedHeightmap::deSerialize(is, &m_padb);
+ u32 count = m_chunks.size();
+
+ dstream<<"INFO: ServerMap::saveChunkMeta(): Saving metadata of "
+ <<count<<" chunks"<<std::endl;
+
+ 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);
+
+ u8 buf[4];
+
+ // 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::loadChunkMeta()
+{
+ DSTACK(__FUNCTION_NAME);
+
+ 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)
+ {
+ dstream<<"ERROR: ServerMap::loadChunkMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open chunk metadata");
+ }
+
+ u8 version = 0;
+
+ // 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)
- {
- // This catches unknown crap in directory
- }
+ // We want files
+ if(i2->dir)
+ continue;
+ try{
+ loadBlock(sectorsubdir, i2->name, sector);
}
- }
- return true;
-}
-
-#if 0
-bool ServerMap::deFlushSector(v2s16 p2d)
-{
- DSTACK(__FUNCTION_NAME);
- // See if it already exists in memory
- try{
- MapSector *sector = getSectorNoGenerate(p2d);
- return true;
- }
- catch(InvalidPositionException &e)
- {
- /*
- Try to load the sector from disk.
- */
- if(loadSectorFull(p2d) == true)
+ catch(InvalidFilenameException &e)
{
- return true;
+ // This catches unknown crap in directory
}
}
- return false;
+ return true;
}
-#endif
void ServerMap::saveBlock(MapBlock *block)
{
try{
- // Block file is map/sectors/xxxxxxxx/xxxx
- std::string fullpath = m_savedir+"/sectors/"+sectordir+"/"+blockfile;
- std::ifstream is(fullpath.c_str(), std::ios_base::binary);
- if(is.good() == false)
- throw FileNotGoodException("Cannot open block file");
+ // Block file is map/sectors/xxxxxxxx/xxxx
+ std::string fullpath = m_savedir+"/sectors/"+sectordir+"/"+blockfile;
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if(is.good() == false)
+ throw FileNotGoodException("Cannot open block file");
- v3s16 p3d = getBlockPos(sectordir, blockfile);
- v2s16 p2d(p3d.X, p3d.Z);
-
- assert(sector->getPos() == p2d);
-
- u8 version = SER_FMT_VER_INVALID;
- is.read((char*)&version, 1);
+ v3s16 p3d = getBlockPos(sectordir, blockfile);
+ v2s16 p2d(p3d.X, p3d.Z);
+
+ assert(sector->getPos() == p2d);
+
+ u8 version = SER_FMT_VER_INVALID;
+ is.read((char*)&version, 1);
- /*u32 block_size = MapBlock::serializedLength(version);
- SharedBuffer<u8> data(block_size);
- is.read((char*)*data, block_size);*/
+ if(is.fail())
+ throw SerializationError("ServerMap::loadBlock(): Failed"
+ " to read MapBlock version");
- // This will always return a sector because we're the server
- //MapSector *sector = emergeSector(p2d);
+ /*u32 block_size = MapBlock::serializedLength(version);
+ SharedBuffer<u8> data(block_size);
+ is.read((char*)*data, block_size);*/
- MapBlock *block = NULL;
- bool created_new = false;
- try{
- block = sector->getBlockNoCreate(p3d.Y);
- }
- catch(InvalidPositionException &e)
- {
- block = sector->createBlankBlockNoInsert(p3d.Y);
- created_new = true;
- }
-
- // deserialize block data
- block->deSerialize(is, version);
-
- /*
- Versions up from 9 have block objects.
- */
- if(version >= 9)
- {
- block->updateObjects(is, version, NULL, 0);
- }
+ // This will always return a sector because we're the server
+ //MapSector *sector = emergeSector(p2d);
- if(created_new)
- sector->insertBlock(block);
-
- /*
- Convert old formats to new and save
- */
+ MapBlock *block = NULL;
+ bool created_new = false;
+ try{
+ block = sector->getBlockNoCreate(p3d.Y);
+ }
+ catch(InvalidPositionException &e)
+ {
+ block = sector->createBlankBlockNoInsert(p3d.Y);
+ created_new = true;
+ }
+
+ // deserialize block data
+ block->deSerialize(is, version);
+
+ /*
+ Versions up from 9 have block objects.
+ */
+ if(version >= 9)
+ {
+ block->updateObjects(is, version, NULL, 0);
+ }
- // Save old format blocks in new format
- if(version < SER_FMT_VER_HIGHEST)
- {
- saveBlock(block);
- }
-
- // We just loaded it from the disk, so it's up-to-date.
- block->resetChangedFlag();
+ if(created_new)
+ sector->insertBlock(block);
+
+ /*
+ Convert old formats to new and save
+ */
+
+ // Save old format blocks in new format
+ if(version < SER_FMT_VER_HIGHEST)
+ {
+ saveBlock(block);
+ }
+
+ // We just loaded it from the disk, so it's up-to-date.
+ block->resetChangedFlag();
}
catch(SerializationError &e)
{
dstream<<"WARNING: Invalid block data on disk "
- "(SerializationError). Ignoring."
+ "(SerializationError). Ignoring. "
+ "A new one will be generated."
<<std::endl;
}
}
-// Gets from master heightmap
-void ServerMap::getSectorCorners(v2s16 p2d, s16 *corners)
-{
- assert(m_heightmap != NULL);
- /*
- Corner definition:
- v2s16(0,0),
- v2s16(1,0),
- v2s16(1,1),
- v2s16(0,1),
- */
- 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);
-}
-
void ServerMap::PrintInfo(std::ostream &out)
{
out<<"ServerMap: ";
Map(dout_client),
scene::ISceneNode(parent, mgr, id),
m_client(client),
- mesh(NULL),
- m_control(control)
+ m_control(control),
+ m_camera_position(0,0,0),
+ m_camera_direction(0,0,1)
{
- mesh_mutex.Init();
-
- /*m_box = core::aabbox3d<f32>(0,0,0,
- map->getW()*BS, map->getH()*BS, map->getD()*BS);*/
- /*m_box = core::aabbox3d<f32>(0,0,0,
- map->getSizeNodes().X * BS,
- map->getSizeNodes().Y * BS,
- map->getSizeNodes().Z * BS);*/
+ m_camera_mutex.Init();
+ assert(m_camera_mutex.IsInitialized());
+
m_box = core::aabbox3d<f32>(-BS*1000000,-BS*1000000,-BS*1000000,
BS*1000000,BS*1000000,BS*1000000);
-
- //setPosition(v3f(BS,BS,BS));
}
ClientMap::~ClientMap()
{
- JMutexAutoLock lock(mesh_mutex);
+ /*JMutexAutoLock lock(mesh_mutex);
if(mesh != NULL)
{
mesh->drop();
mesh = NULL;
- }
+ }*/
}
MapSector * ClientMap::emergeSector(v2s16 p2d)
{
}
- // Create a sector with no heightmaps
+ // Create a sector
ClientMapSector *sector = new ClientMapSector(this, p2d);
{
*/
int time1 = time(0);
- u32 daynight_ratio = m_client->getDayNightRatio();
+ //u32 daynight_ratio = m_client->getDayNightRatio();
m_camera_mutex.Lock();
v3f camera_position = m_camera_position;
timecheck_counter++;
if(timecheck_counter > 50)
{
+ timecheck_counter = 0;
int time2 = time(0);
if(time2 > time1 + 4)
{
float range = 100000 * BS;
if(m_control.range_all == false)
range = m_control.wanted_range * BS;
-
+
+ float d = 0.0;
if(isBlockInSight(block->getPos(), camera_position,
- camera_direction, range) == false)
+ camera_direction, range, &d) == false)
{
continue;
}
-
-#if 0
- 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(m_control.range_all == false)
- {
- // If block is far away, don't draw it
- if(d > m_control.wanted_range * BS)
- continue;
- }
-
- // Maximum radius of a block
- f32 block_max_radius = 0.5*1.44*1.44*MAP_BLOCKSIZE*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)
- {
- // 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;
- }
-#endif
+ // This is ugly (spherical distance limit?)
+ /*if(m_control.range_all == false &&
+ d - 0.5*BS*MAP_BLOCKSIZE > range)
+ continue;*/
- 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;
-
- // Total distance
- f32 d = blockpos_relative.getLength();
-
#if 1
/*
- Update expired mesh
+ Update expired mesh (used for day/night change)
+
+ It doesn't work exactly like it should now with the
+ tasked mesh update but whatever.
*/
bool mesh_expired = false;
mesh_update_count++;
// Mesh has been expired: generate new mesh
- //block->updateMeshes(daynight_i);
- block->updateMesh(daynight_ratio);
+ //block->updateMesh(daynight_ratio);
+ m_client->addUpdateMeshTask(block->getPos());
mesh_expired = false;
}
- /*
- Don't draw an expired mesh that is far away
- */
- /*if(mesh_expired && d >= faraway)
- //if(mesh_expired)
- {
- // Instead, delete it
- JMutexAutoLock lock(block->mesh_mutex);
- if(block->mesh)
- {
- block->mesh->drop();
- block->mesh = NULL;
- }
- // And continue to next block
- continue;
- }*/
#endif
/*
Draw the faces of the block
// 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();
return changed;
}
+void ClientMap::expireMeshes(bool only_daynight_diffed)
+{
+ TimeTaker timer("expireMeshes()");
+
+ core::map<v2s16, MapSector*>::Iterator si;
+ si = m_sectors.getIterator();
+ for(; si.atEnd() == false; si++)
+ {
+ MapSector *sector = si.getNode()->getValue();
+
+ core::list< MapBlock * > sectorblocks;
+ sector->getBlocks(sectorblocks);
+
+ core::list< MapBlock * >::Iterator i;
+ for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++)
+ {
+ MapBlock *block = *i;
+
+ if(only_daynight_diffed && dayNightDiffed(block->getPos()) == false)
+ {
+ continue;
+ }
+
+ {
+ JMutexAutoLock lock(block->mesh_mutex);
+ if(block->mesh != NULL)
+ {
+ /*block->mesh->drop();
+ block->mesh = NULL;*/
+ block->setMeshExpired(true);
+ }
+ }
+ }
+ }
+}
+
+void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio)
+{
+ assert(mapType() == MAPTYPE_CLIENT);
+
+ try{
+ v3s16 p = blockpos + v3s16(0,0,0);
+ MapBlock *b = getBlockNoCreate(p);
+ b->updateMesh(daynight_ratio);
+ //b->setMeshExpired(true);
+ }
+ catch(InvalidPositionException &e){}
+ // Leading edge
+ try{
+ v3s16 p = blockpos + v3s16(-1,0,0);
+ MapBlock *b = getBlockNoCreate(p);
+ b->updateMesh(daynight_ratio);
+ //b->setMeshExpired(true);
+ }
+ catch(InvalidPositionException &e){}
+ try{
+ v3s16 p = blockpos + v3s16(0,-1,0);
+ MapBlock *b = getBlockNoCreate(p);
+ b->updateMesh(daynight_ratio);
+ //b->setMeshExpired(true);
+ }
+ catch(InvalidPositionException &e){}
+ try{
+ v3s16 p = blockpos + v3s16(0,0,-1);
+ MapBlock *b = getBlockNoCreate(p);
+ b->updateMesh(daynight_ratio);
+ //b->setMeshExpired(true);
+ }
+ catch(InvalidPositionException &e){}
+}
+
+#if 0
+/*
+ Update mesh of block in which the node is, and if the node is at the
+ leading edge, update the appropriate leading blocks too.
+*/
+void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio)
+{
+ v3s16 dirs[4] = {
+ v3s16(0,0,0),
+ v3s16(-1,0,0),
+ v3s16(0,-1,0),
+ v3s16(0,0,-1),
+ };
+ v3s16 blockposes[4];
+ for(u32 i=0; i<4; i++)
+ {
+ v3s16 np = nodepos + dirs[i];
+ blockposes[i] = getNodeBlockPos(np);
+ // Don't update mesh of block if it has been done already
+ bool already_updated = false;
+ for(u32 j=0; j<i; j++)
+ {
+ if(blockposes[j] == blockposes[i])
+ {
+ already_updated = true;
+ break;
+ }
+ }
+ if(already_updated)
+ continue;
+ // Update mesh
+ MapBlock *b = getBlockNoCreate(blockposes[i]);
+ b->updateMesh(daynight_ratio);
+ }
+}
+#endif
+
void ClientMap::PrintInfo(std::ostream &out)
{
out<<"ClientMap: ";
projects / dragonfireclient.git / blobdiff