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_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)
{
//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
*/
//m_chunksize = 2;
// TODO: Save to and load from a file
- m_seed = (((u64)myrand()<<0)%0x7fff)
- + (((u64)myrand()<<16)%0x7fff)
- + (((u64)myrand()<<32)%0x7fff)
- + (((u64)myrand()<<48)%0x7fff);
+ m_seed = (((u64)(myrand()%0xffff)<<0)
+ + ((u64)(myrand()%0xffff)<<16)
+ + ((u64)(myrand()%0xffff)<<32)
+ + ((u64)(myrand()%0xffff)<<48));
/*
Experimental and debug stuff
}
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;
+ dstream<<DTIME<<"INFO: Initializing new map."<<std::endl;
// Create zero sector
emergeSector(v2s16(0,0));
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;
-}*/
+#define AVERAGE_MUD_AMOUNT 4
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/250., 0.5+(float)p.Y/250.,
+ 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 b = 20;
// Offset to more low
- double a_off = -0.15;
+ 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.,
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)
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.
{
s16 min_tunnel_diameter = 2;
s16 max_tunnel_diameter = 6;
- u16 tunnel_routepoints = 15;
+ u16 tunnel_routepoints = 25;
bool bruise_surface = (jj < bruises_count);
of -= v3s16(1,0,1) * more;
s16 route_y_min = 0;
- //s16 route_y_max = ar.Y-1;
- s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2;
- // If dungeons
+ // 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)
- {
- // Don't go through surface too often
- route_y_max -= myrand_range(0, max_tunnel_diameter*2);
- }
+ 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)
/*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
);
s16 max_d = max_tunnel_diameter;
s16 rs = myrand_range(min_d, max_d);
- v3s16 maxlen(15, 5, 15);
-
+ 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 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;
//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+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/2000; 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,
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);
// 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
//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;
}
/*
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
{
//dstream<<"generateBlock: x0="<<x0<<", z0="<<z0<<std::endl;
- s16 surface_y = 0;
+ //s16 surface_y = 0;
+
+ s16 surface_y = base_rock_level_2d(m_seed, p2d_nodes+v2s16(x0,z0))
+ + AVERAGE_MUD_AMOUNT;
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 = 2;
+ s32 surface_depth = AVERAGE_MUD_AMOUNT;
for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
//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);
}
}
DSTACK("%s: p=(%d,%d,%d)",
__FUNCTION_NAME, p.X, p.Y, p.Z);
+ /*
+ Do not create over-limit
+ */
+ if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+ throw InvalidPositionException("createBlock(): pos. over limit");
+
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
/*
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)
+{
+ /*
+ Uh, just do something random...
+ */
+ // Find existing map from top to down
+ s16 max=63;
+ s16 min=-64;
+ v3s16 p(p2d.X, max, p2d.Y);
+ for(; p.Y>min; p.Y--)
+ {
+ MapNode n = getNodeNoEx(p);
+ if(n.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--)
+ {
+ MapNode n = getNodeNoEx(p);
+ if(content_walkable(n.d) && n.d != CONTENT_IGNORE)
+ return p.Y;
+ }
+ // 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)
{
if(fs::CreateDir(path) == false)
dstream<<DTIME<<"ServerMap: Saving whole map, this can take time."
<<std::endl;
- saveMasterHeightmap();
+ saveMapMeta();
+ saveChunkMeta();
u32 sector_meta_count = 0;
u32 block_count = 0;
{
DSTACK(__FUNCTION_NAME);
dstream<<DTIME<<"ServerMap: Loading map..."<<std::endl;
-
- loadMasterHeightmap();
+
+ loadMapMeta();
+ loadChunkMeta();
std::vector<fs::DirListNode> list = fs::GetDirListing(m_savedir+"/sectors/");
dstream<<DTIME<<"ServerMap: Map loaded."<<std::endl;
}
+#if 0
void ServerMap::saveMasterHeightmap()
{
DSTACK(__FUNCTION_NAME);
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::string fullpath = m_savedir + "/map_meta.txt";
+ std::ifstream is(fullpath.c_str(), std::ios_base::binary);
+ if(is.good() == false)
+ {
+ dstream<<"ERROR: ServerMap::loadMapMeta(): "
+ <<"could not open"<<fullpath<<std::endl;
+ throw FileNotGoodException("Cannot open 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);
+
+ 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_sectors);
{
return false;
}
-
+
+ /*
+ Load blocks
+ */
std::vector<fs::DirListNode> list2 = fs::GetDirListing
(m_savedir+"/sectors/"+sectorsubdir);
std::vector<fs::DirListNode>::iterator i2;
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)
- {
- return true;
- }
- }
- return false;
-}
-#endif
-
void ServerMap::saveBlock(MapBlock *block)
{
DSTACK(__FUNCTION_NAME);
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)
-{
- dstream<<"DEPRECATED: "<<__FUNCTION_NAME<<std::endl;
- //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),
- 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()
{
}
- // 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;
{
continue;
}
+
+ // This is ugly (spherical distance limit?)
+ /*if(m_control.range_all == false &&
+ d - 0.5*BS*MAP_BLOCKSIZE > range)
+ continue;*/
#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
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: ";