X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=cd2ba9154eadac0202782697b47cf2ff5052ce92;hb=d4d49ee8f4d425e7a4136d65f519728869680951;hp=ba958d148f00ec665cc5a8b3d05d8ae2d1f8d257;hpb=52d99fef31daa60903053bc565b6b9d3a31a2bc8;p=dragonfireclient.git diff --git a/src/map.cpp b/src/map.cpp index ba958d148..cd2ba9154 100644 --- a/src/map.cpp +++ b/src/map.cpp @@ -1,6 +1,6 @@ /* Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Copyright (C) 2010-2011 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -27,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "porting.h" #include "mineral.h" #include "noise.h" +#include "serverobject.h" /* Map @@ -34,30 +35,16 @@ with this program; if not, write to the Free Software Foundation, Inc., 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)); + /*m_sector_mutex.Init(); + assert(m_sector_mutex.IsInitialized());*/ } Map::~Map() { /* - Stop updater thread - */ - /*updater.setRun(false); - while(updater.IsRunning()) - sleep_s(1);*/ - - /* - Free all MapSectors. + Free all MapSectors */ core::map::Iterator i = m_sectors.getIterator(); for(; i.atEnd() == false; i++) @@ -67,6 +54,29 @@ Map::~Map() } } +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::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){ @@ -94,7 +104,7 @@ MapSector * Map::getSectorNoGenerateNoExNoLock(v2s16 p) MapSector * Map::getSectorNoGenerateNoEx(v2s16 p) { - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out return getSectorNoGenerateNoExNoLock(p); } @@ -145,34 +155,6 @@ MapBlock * Map::getBlockNoCreateNoEx(v3s16 p3d) 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<mutex.Lock(); - sref->setGroundHeight(relpos, y); - //sref->mutex.Unlock(); -} - bool Map::isNodeUnderground(v3s16 p) { v3s16 blockpos = getNodeBlockPos(p); @@ -860,15 +842,13 @@ void Map::updateLighting(core::map & a_blocks, 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 &modified_blocks)*/ void Map::addNodeAndUpdate(v3s16 p, MapNode n, core::map &modified_blocks) { /*PrintInfo(m_dout); - m_dout<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--){ @@ -975,7 +992,6 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, if(n2.getLight(LIGHTBANK_DAY) == LIGHT_SUN) { - //m_dout<::Iterator si; - si = m_sectors.getIterator(); - for(; si.atEnd() == false; si++) - { - MapSector *sector = si.getNode()->getValue(); + bool succeeded = true; + try{ + core::map 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::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 modified_blocks; + removeNodeAndUpdate(p, modified_blocks); + + // Copy modified_blocks to event + for(core::map::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) { @@ -1358,7 +1347,7 @@ bool Map::dayNightDiffed(v3s16 blockpos) */ void Map::timerUpdate(float dtime) { - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out core::map::Iterator si; @@ -1408,7 +1397,7 @@ void Map::deleteSectors(core::list &list, bool only_blocks) u32 Map::deleteUnusedSectors(float timeout, bool only_blocks, core::list *deleted_blocks) { - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out core::list sector_deletion_queue; core::map::Iterator i = m_sectors.getIterator(); @@ -1725,14 +1714,88 @@ void Map::transformLiquids(core::map & modified_blocks) //dstream<<"Map::transformLiquids(): loopcount="<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" + <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" + <m_node_metadata.remove(p_rel); +} + +void Map::nodeMetadataStep(float dtime, + core::map &changed_blocks) +{ + /* + NOTE: + Currently there is no way to ensure that all the necessary + blocks are loaded when this is run. (They might get unloaded) + NOTE: ^- Actually, that might not be so. In a quick test it + reloaded a block with a furnace when I walked back to it from + a distance. + */ + core::map::Iterator si; + si = m_sectors.getIterator(); + for(; si.atEnd() == false; si++) + { + MapSector *sector = si.getNode()->getValue(); + core::list< MapBlock * > sectorblocks; + sector->getBlocks(sectorblocks); + core::list< MapBlock * >::Iterator i; + for(i=sectorblocks.begin(); i!=sectorblocks.end(); i++) + { + MapBlock *block = *i; + bool changed = block->m_node_metadata.step(dtime); + if(changed) + changed_blocks[block->getPos()] = block; + } + } +} + /* ServerMap */ ServerMap::ServerMap(std::string savedir): Map(dout_server), - m_seed(0) + m_seed(0), + m_map_metadata_changed(true) { + dstream<<__FUNCTION_NAME< 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 + + 20. * noise2d_perlin( + 0.5+(float)p.X/500., 0.5+(float)p.Y/500., (seed>>32)+654879876, 6, 0.6); /*// A bit hillier one @@ -2029,7 +2080,7 @@ double base_rock_level_2d(u64 seed, v2s16 p) base = base2;*/ #if 1 // Higher ground level - double higher = (double)WATER_LEVEL + 25. + 45. * noise2d_perlin( + double higher = (double)WATER_LEVEL + 25. + 35. * noise2d_perlin( 0.5+(float)p.X/250., 0.5+(float)p.Y/250., seed+85039, 5, 0.69); //higher = 30; // For debugging @@ -2050,7 +2101,7 @@ double base_rock_level_2d(u64 seed, v2s16 p) //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., @@ -2070,182 +2121,240 @@ double base_rock_level_2d(u64 seed, v2s16 p) return h; } -#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1 +double get_mud_add_amount(u64 seed, v2s16 p) +{ + return ((float)AVERAGE_MUD_AMOUNT + 3.0 * noise2d_perlin( + 0.5+(float)p.X/200, 0.5+(float)p.Y/200, + seed+91013, 3, 0.55)); +} /* - This is the main map generation method + Adds random objects to block, depending on the content of the block */ - -MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, - core::map &changed_blocks) +void addRandomObjects(MapBlock *block) { - DSTACK(__FUNCTION_NAME); - - /* - Don't generate if already fully generated - */ + for(s16 z0=0; z0getGenLevel() == GENERATED_FULLY) + bool last_node_walkable = false; + for(s16 y0=0; y0getNodeNoEx(p); + if(n.d == CONTENT_IGNORE) + continue; + if(content_features(n.d).liquid_type != LIQUID_NONE) + continue; + if(content_features(n.d).walkable) + { + last_node_walkable = true; + continue; + } + if(last_node_walkable) + { + // If block contains light information + if(content_features(n.d).param_type == CPT_LIGHT) + { + if(n.getLight(LIGHTBANK_DAY) <= 3) + { + if(myrand() % 300 == 0) + { + v3f pos_f = intToFloat(p+block->getPosRelative(), BS); + pos_f.Y -= BS*0.4; + ServerActiveObject *obj = new RatSAO(NULL, 0, pos_f); + std::string data = obj->getStaticData(); + StaticObject s_obj(obj->getType(), + obj->getBasePosition(), data); + // Add some + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + delete obj; + } + if(myrand() % 300 == 0) + { + v3f pos_f = intToFloat(p+block->getPosRelative(), BS); + pos_f.Y -= BS*0.4; + ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f); + std::string data = obj->getStaticData(); + StaticObject s_obj(obj->getType(), + obj->getBasePosition(), data); + // Add one + block->m_static_objects.insert(0, s_obj); + delete obj; + } + } + } + } + last_node_walkable = false; } } + block->setChangedFlag(); +} - dstream<<"generateChunkRaw(): Generating chunk " - <<"("<no_op) + return; + + s16 y_nodes_min = data->y_blocks_min * MAP_BLOCKSIZE; + s16 y_nodes_max = data->y_blocks_max * MAP_BLOCKSIZE + MAP_BLOCKSIZE - 1; + s16 h_blocks = data->y_blocks_max - data->y_blocks_min + 1; + u32 relative_volume = (u32)data->sectorpos_base_size*MAP_BLOCKSIZE + *(u32)data->sectorpos_base_size*MAP_BLOCKSIZE + *(u32)h_blocks*MAP_BLOCKSIZE; v3s16 bigarea_blocks_min( - sectorpos_bigbase.X, - y_blocks_min, - sectorpos_bigbase.Y + data->sectorpos_bigbase.X, + data->y_blocks_min, + data->sectorpos_bigbase.Y ); - v3s16 bigarea_blocks_max( - sectorpos_bigbase.X + sectorpos_bigbase_size - 1, - y_blocks_max, - sectorpos_bigbase.Y + sectorpos_bigbase_size - 1 + data->sectorpos_bigbase.X + data->sectorpos_bigbase_size - 1, + data->y_blocks_max, + data->sectorpos_bigbase.Y + data->sectorpos_bigbase_size - 1 ); - - // Relative values to control amount of stuff in one chunk - /*u32 relative_area = (u32)sectorpos_base_size*MAP_BLOCKSIZE - *(u32)sectorpos_base_size*MAP_BLOCKSIZE;*/ - u32 relative_volume = (u32)sectorpos_base_size*MAP_BLOCKSIZE - *(u32)sectorpos_base_size*MAP_BLOCKSIZE - *(u32)h_blocks*MAP_BLOCKSIZE; - - /* - The limiting edges of the lighting update, inclusive. - */ - s16 lighting_min_d = 0-max_spread_amount; - s16 lighting_max_d = sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-1; - - /* - Create the whole area of this and the neighboring chunks - */ - { - TimeTaker timer("generateChunkRaw() create area"); - - for(s16 x=0; xsetLightingExpired(true); - // Lighting will be calculated - block->setLightingExpired(false); - - /* - Block gets sunlight if this is true. - - This should be set to true when the top side of a block - is completely exposed to the sky. - - Actually this doesn't matter now because the - initial lighting is done here. - */ - block->setIsUnderground(y != y_blocks_max); - } - } - } - - /* - Now we have a big empty area. - - Make a ManualMapVoxelManipulator that contains this and the - neighboring chunks - */ - - ManualMapVoxelManipulator vmanip(this); - // Add the area we just generated - { - TimeTaker timer("generateChunkRaw() initialEmerge"); - vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); - } + s16 lighting_min_d = 0-data->max_spread_amount; + s16 lighting_max_d = data->sectorpos_base_size*MAP_BLOCKSIZE + + data->max_spread_amount-1; // Clear all flags - vmanip.clearFlag(0xff); + data->vmanip.clearFlag(0xff); - TimeTaker timer_generate("generateChunkRaw() generate"); + TimeTaker timer_generate("makeChunk() generate"); // Maximum height of the stone surface and obstacles. - // This is used to disable dungeon generation from going too high. + // This is used to disable cave generation from going too high. s16 stone_surface_max_y = 0; /* Generate general ground level to full area */ - { // 22ms @cs=8 - //TimeTaker timer1("ground level"); + TimeTaker timer1("Generating ground level"); + +#if 0 + NoiseBuffer noisebuf1; + //NoiseBuffer noisebuf2; + { + v3f minpos_f( + data->sectorpos_bigbase.X*MAP_BLOCKSIZE, + y_nodes_min, + data->sectorpos_bigbase.Y*MAP_BLOCKSIZE + ); + v3f maxpos_f = minpos_f + v3f( + data->sectorpos_bigbase_size*MAP_BLOCKSIZE, + y_nodes_max-y_nodes_min, + data->sectorpos_bigbase_size*MAP_BLOCKSIZE + ); + v3f samplelength_f = v3f(4.0, 4.0, 4.0); + + TimeTaker timer("noisebuf.create"); + + noisebuf1.create(data->seed+25104, 6, 0.60, 200.0, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z); + /*noisebuf1.create(data->seed+25104, 3, 0.60, 25.0, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z); + noisebuf2.create(data->seed+25105, 4, 0.50, 200.0, + minpos_f.X, minpos_f.Y, minpos_f.Z, + maxpos_f.X, maxpos_f.Y, maxpos_f.Z, + samplelength_f.X, samplelength_f.Y, samplelength_f.Z);*/ + } + + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) + { + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + // Ground height at this point + float surface_y_f = 0.0; + + // Use perlin noise for ground height + surface_y_f = base_rock_level_2d(data->seed, p2d); + //surface_y_f = base_rock_level_2d(data->seed, p2d); + + // Convert to integer + s16 surface_y = (s16)surface_y_f; + + // Log it + if(surface_y > stone_surface_max_y) + stone_surface_max_y = surface_y; + + /* + Fill ground with stone + */ + { + // Use fast index incrementing + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + for(s16 y=y_nodes_min; y<=y_nodes_max; y++) + { + // Skip if already generated. + // This is done here because there might be a cave at + // any point in ground, which could look like it + // wasn't generated. + if(data->vmanip.m_data[i].d != CONTENT_AIR) + break; - for(s16 x=0; xseed+123, 5, 0.5);*/ + double noiseval = 64.0 * noisebuf1.get(p2d.X, y, p2d.Y); + /*double noiseval = 30.0 * noisebuf1.get(p2d.X, y, p2d.Y); + noiseval *= MYMAX(0, -0.2 + noisebuf2.get(p2d.X, y, p2d.Y));*/ + + //if(y < surface_y + noiseval) + if(noiseval > 0) + //if(noiseval > y) + data->vmanip.m_data[i].d = CONTENT_STONE; + + data->vmanip.m_area.add_y(em, i, 1); + } + } + } +#endif + +#if 1 + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) { // Node position - v2s16 p2d = sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); /* Skip of already generated */ - { + /*{ v3s16 p(p2d.X, y_nodes_min, p2d.Y); - if(vmanip.m_data[vmanip.m_area.index(p)].d != CONTENT_AIR) + if(data->vmanip.m_data[data->vmanip.m_area.index(p)].d != CONTENT_AIR) continue; - } + }*/ // Ground height at this point float surface_y_f = 0.0; // Use perlin noise for ground height - surface_y_f = base_rock_level_2d(m_seed, p2d); + surface_y_f = base_rock_level_2d(data->seed, p2d); /*// Experimental stuff { - float a = highlands_level_2d(m_seed, p2d); + float a = highlands_level_2d(data->seed, p2d); if(a > surface_y_f) surface_y_f = a; }*/ @@ -2262,16 +2371,24 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); for(s16 y=y_nodes_min; yvmanip.m_data[i].d != CONTENT_AIR) + break; - vmanip.m_area.add_y(em, i, 1); + data->vmanip.m_data[i].d = CONTENT_STONE; + + data->vmanip.m_area.add_y(em, i, 1); } } } +#endif }//timer1 @@ -2279,167 +2396,49 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Randomize some parameters */ - s32 stone_obstacle_count = 0; + //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);*/ + rangelim((1.0+noise2d(data->seed+897, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ - s16 stone_obstacle_max_height = 0; + //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);*/ + rangelim((1.0+noise2d(data->seed+5902, + data->sectorpos_base.X, data->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++) + const u32 age_loops = 2; + for(u32 i_age=0; i_age=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - /*if(content_walkable(n.d) - && n.d != CONTENT_MUD - && n.d != CONTENT_GRASS) - break;*/ - if(n->d == CONTENT_STONE) - break; - - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - { - mud_amount++; - /* - Change to mud because otherwise we might - be throwing mud on grass at the next - step - */ - n->d = CONTENT_MUD; - } - - vmanip.m_area.add_y(em, i, -1); - } - if(y >= y_nodes_min) - surface_y = y; - else - surface_y = y_nodes_min; - } - - - /* - Add stone on ground - */ - { - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = surface_y+1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - s16 y; - // Add stone - s16 count = 0; - for(y=y_start; y<=y_nodes_max - min_head_space; y++) - { - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_STONE; - - if(y > stone_surface_max_y) - stone_surface_max_y = y; - - count++; - if(count >= ob_size.Y) - break; - - vmanip.m_area.add_y(em, i, 1); - } - // Add mud - count = 0; - for(; y<=y_nodes_max - min_head_space; y++) - { - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_MUD; - count++; - if(count >= mud_amount) - break; - - vmanip.m_area.add_y(em, i, 1); - } - } - - } - } - - }//timer1 +#if 1 { // 24ms @cs=8 - //TimeTaker timer1("dungeons"); + //TimeTaker timer1("caves"); /* - Make dungeons + Make caves */ - u32 dungeons_count = relative_volume / 400000; + u32 caves_count = relative_volume / 400000; 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 caves_count = 0; u32 bruises_count = 0;*/ - for(u32 jj=0; jj caves_count); if(bruise_surface) { @@ -2448,31 +2447,34 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, /*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);*/ + /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(data->seed+42, + data->sectorpos_base.X, data->sectorpos_base.Y)), 0, 15);*/ tunnel_routepoints = 5; } + else + { + } // Allowed route area size in nodes v3s16 ar( - sectorpos_base_size*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE, h_blocks*MAP_BLOCKSIZE, - sectorpos_base_size*MAP_BLOCKSIZE + data->sectorpos_base_size*MAP_BLOCKSIZE ); // Area starting point in nodes v3s16 of( - sectorpos_base.X*MAP_BLOCKSIZE, - y_blocks_min*MAP_BLOCKSIZE, - sectorpos_base.Y*MAP_BLOCKSIZE + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE ); // Allow a bit more //(this should be more than the maximum radius of the tunnel) //s16 insure = 5; // Didn't work with max_d = 20 s16 insure = 10; - s16 more = max_spread_amount - max_tunnel_diameter/2 - insure; + s16 more = data->max_spread_amount - max_tunnel_diameter/2 - insure; ar += v3s16(1,0,1) * more * 2; of -= v3s16(1,0,1) * more; @@ -2480,7 +2482,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // 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 caves, don't go through surface too often if(bruise_surface == false) route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/ @@ -2505,16 +2507,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, s16 route_start_y_min = route_y_min; s16 route_start_y_max = route_y_max; - // Start every 2nd dungeon from surface + // Start every 2nd cave 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 = -of.Y + stone_surface_max_y + 10; } 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); + route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y-1); // Randomize starting position v3f orp( @@ -2531,6 +2533,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, for(u16 j=0; jvmanip.m_area.contains(p)); + if(data->vmanip.m_area.contains(p) == false) { dstream<<"WARNING: "<<__FUNCTION_NAME <<":"<<__LINE__<<": " @@ -2622,13 +2636,13 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Just set it to air, it will be changed to // water afterwards - u32 i = vmanip.m_area.index(p); - vmanip.m_data[i] = airnode; + u32 i = data->vmanip.m_area.index(p); + data->vmanip.m_data[i] = airnode; if(bruise_surface == false) { // Set tunnel flag - vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; + data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; } } } @@ -2641,6 +2655,9 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 46ms @cs=8 //TimeTaker timer1("ore veins"); @@ -2648,28 +2665,28 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, /* Make ore veins */ - for(u32 jj=0; jjsectorpos_base_size*MAP_BLOCKSIZE, h_blocks*MAP_BLOCKSIZE, - sectorpos_base_size*MAP_BLOCKSIZE + data->sectorpos_base_size*MAP_BLOCKSIZE ); // Area starting point in nodes v3s16 of( - sectorpos_base.X*MAP_BLOCKSIZE, - y_blocks_min*MAP_BLOCKSIZE, - sectorpos_base.Y*MAP_BLOCKSIZE + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE ); // Allow a bit more //(this should be more than the maximum radius of the tunnel) s16 insure = 3; - s16 more = max_spread_amount - max_vein_diameter/2 - insure; + s16 more = data->max_spread_amount - max_vein_diameter/2 - insure; ar += v3s16(1,0,1) * more * 2; of -= v3s16(1,0,1) * more; @@ -2681,7 +2698,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, ); // 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 @@ -2696,7 +2717,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, ); 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, @@ -2751,12 +2772,12 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, continue; p += of; - assert(vmanip.m_area.contains(p)); + assert(data->vmanip.m_area.contains(p)); // Just set it to air, it will be changed to // water afterwards - u32 i = vmanip.m_area.index(p); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(p); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_STONE) n->param = mineral; } @@ -2770,27 +2791,28 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 15ms @cs=8 - //TimeTaker timer1("add mud"); + TimeTaker timer1("add mud"); /* Add mud to the central chunk */ - for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->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)); + s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0; // Find ground level - s16 surface_y = find_ground_level_clever(vmanip, p2d); + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); /* If topmost node is grass, change it to mud. @@ -2798,10 +2820,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, chunk and then converted. */ { - u32 i = vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_GRASS) - n->d = CONTENT_MUD; + *n = MapNode(CONTENT_MUD); + //n->d = CONTENT_MUD; } /* @@ -2809,25 +2832,29 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { s16 mudcount = 0; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = surface_y+1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->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; + MapNode &n = data->vmanip.m_data[i]; + n = MapNode(CONTENT_MUD); + //n.d = CONTENT_MUD; mudcount++; - vmanip.m_area.add_y(em, i, 1); + data->vmanip.m_area.add_y(em, i, 1); } } } }//timer1 +#endif + +#if 1 { // 340ms @cs=8 TimeTaker timer1("flow mud"); @@ -2837,8 +2864,8 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ // 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; + s16 mudflow_minpos = 0-data->max_spread_amount+1; + s16 mudflow_maxpos = data->sectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-2; // Iterate a few times for(s16 k=0; k<3; k++) @@ -2859,10 +2886,10 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->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)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); s16 y=y_nodes_max; for(;; y--) @@ -2871,22 +2898,22 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Find mud for(; y>=y_nodes_min; y--) { - n = &vmanip.m_data[i]; + n = &data->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); + data->vmanip.m_area.add_y(em, i, -1); } // Stop if out of area - //if(vmanip.m_area.contains(i) == false) + //if(data->vmanip.m_area.contains(i) == false) if(y < y_nodes_min) break; /*// If not mud, do nothing to it - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) continue;*/ @@ -2895,11 +2922,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { u32 i2 = i; - vmanip.m_area.add_y(em, i2, -1); + data->vmanip.m_area.add_y(em, i2, -1); // Cancel if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; - MapNode *n2 = &vmanip.m_data[i2]; + MapNode *n2 = &data->vmanip.m_data[i2]; if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS) continue; } @@ -2920,9 +2947,9 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // 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) + data->vmanip.m_area.add_y(em, i3, 1); + if(data->vmanip.m_area.contains(i3) == true + && content_walkable(data->vmanip.m_data[i3].d) == true) { continue; } @@ -2934,39 +2961,39 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, v3s16 dirp = dirs4[di]; u32 i2 = i; // Move to side - vmanip.m_area.add_p(em, i2, dirp); + data->vmanip.m_area.add_p(em, i2, dirp); // Fail if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; // Check that side is air - MapNode *n2 = &vmanip.m_data[i2]; + MapNode *n2 = &data->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) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->vmanip.m_data[i2]; if(content_walkable(n2->d)) continue; /*// Check that under that is air (need a drop of 2) - vmanip.m_area.add_y(em, i2, -1); - if(vmanip.m_area.contains(i2) == false) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->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); + data->vmanip.m_area.add_y(em, i2, -1); // Fail if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->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]; + data->vmanip.m_area.add_y(em, i2, 1); + n2 = &data->vmanip.m_data[i2]; // Move mud to new place *n2 = *n; @@ -2982,26 +3009,29 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 50ms @cs=8 - //TimeTaker timer1("add water"); + TimeTaker timer1("add water"); /* Add water to the central chunk (and a bit more) */ - for(s16 x=0-max_spread_amount; - xmax_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; x++) - for(s16 z=0-max_spread_amount; - zmax_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Find ground level - //s16 surface_y = find_ground_level(vmanip, p2d); + //s16 surface_y = find_ground_level(data->vmanip, p2d); /* If ground level is over water level, skip. @@ -3016,42 +3046,27 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Add water on ground */ { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); u8 light = LIGHT_MAX; // Start at global water surface level s16 y_start = WATER_LEVEL; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; - - /*// Add first one to transforming liquid queue, if water - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y_start, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; for(s16 y=y_start; y>=y_nodes_min; y--) { - n = &vmanip.m_data[i]; + n = &data->vmanip.m_data[i]; // Stop when there is no water and no air if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE && n->d != CONTENT_WATER) { - /*// Add bottom one to transforming liquid queue - vmanip.m_area.add_y(em, i, 1); - n = &vmanip.m_data[i]; - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ break; } - // Make water only not in dungeons - if(!(vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) + // Make water only not in caves + if(!(data->vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) { n->d = CONTENT_WATERSOURCE; //n->setLight(LIGHTBANK_DAY, light); @@ -3059,11 +3074,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // 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); + data->transforming_liquid.push_back(p); } // Next one - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); if(light > 0) light--; } @@ -3072,9 +3087,14 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif } // Aging loop + /*********************** + END OF AGING LOOP + ************************/ +#if 1 { //TimeTaker timer1("convert mud to sand"); @@ -3085,22 +3105,22 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, //s16 mud_add_amount = myrand_range(2, 4); //s16 mud_add_amount = 0; - /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; x++) - for(s16 z=0-max_spread_amount+1; - zmax_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Determine whether to have sand here double sandnoise = noise2d_perlin( 0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500, - m_seed+59420, 3, 0.50); + data->seed+59420, 3, 0.50); bool have_sand = (sandnoise > -0.15); @@ -3108,19 +3128,19 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, continue; // Find ground level - s16 surface_y = find_ground_level_clever(vmanip, p2d); + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); if(surface_y > WATER_LEVEL + 2) continue; { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = surface_y; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->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]; + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) { n->d = CONTENT_SAND; @@ -3132,13 +3152,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, break; } - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } }//timer1 +#endif + +#if 1 { // 1ms @cs=8 //TimeTaker timer1("generate trees"); @@ -3149,72 +3172,77 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { // Divide area into parts s16 div = 8; - s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; + s16 sidelen = data->sectorpos_base_size*MAP_BLOCKSIZE / div; double area = sidelen * sidelen; for(s16 x0=0; x0sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0, + data->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 + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0, + data->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 + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1 ); // Amount of trees - u32 tree_count = area * tree_amount_2d(m_seed, p2d_center); + u32 tree_count = area * tree_amount_2d(data->seed, p2d_center); // Put trees in random places on part of division for(u32 i=0; ivmanip, 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]; + u32 i = data->vmanip.m_area.index(v3s16(p)); + MapNode *n = &data->vmanip.m_data[i]; if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) continue; } p.Y++; // Make a tree - make_tree(vmanip, p); + make_tree(data->vmanip, p); } } /*u32 tree_max = relative_area / 60; //u32 count = myrand_range(0, tree_max); for(u32 i=0; isectorpos_base_size*MAP_BLOCKSIZE-1); + s16 z = myrand_range(0, data->sectorpos_base_size*MAP_BLOCKSIZE-1); + x += data->sectorpos_base.X*MAP_BLOCKSIZE; + z += data->sectorpos_base.Y*MAP_BLOCKSIZE; + s16 y = find_ground_level(data->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); + make_tree(data->vmanip, p); }*/ } }//timer1 +#endif +#if 1 { // 19ms @cs=8 //TimeTaker timer1("grow grass"); @@ -3223,17 +3251,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Grow grass */ - /*for(s16 x=0-4; xsectorpos_base_size*MAP_BLOCKSIZE+4; x++) + for(s16 z=0-4; zsectorpos_base_size*MAP_BLOCKSIZE+4; z++)*/ + for(s16 x=0-data->max_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; x++) - for(s16 z=0-max_spread_amount; - zmax_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); /* Find the lowest surface to which enough light ends up @@ -3243,17 +3271,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ s16 surface_y = 0; { - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); s16 y; // Go to ground level for(y=y_nodes_max; y>=y_nodes_min; y--) { - MapNode &n = vmanip.m_data[i]; + MapNode &n = data->vmanip.m_data[i]; if(n.d != CONTENT_AIR && n.d != CONTENT_LEAVES) break; - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } if(y >= y_nodes_min) surface_y = y; @@ -3261,13 +3289,14 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, surface_y = y_nodes_min; } - u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(p2d.X, surface_y, p2d.Y); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_MUD) n->d = CONTENT_GRASS; } }//timer1 +#endif /* Initial lighting (sunlight) @@ -3279,6 +3308,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // 750ms @cs=8, can't optimize more TimeTaker timer1("initial lighting"); + // NOTE: This is no used... umm... for some reason! #if 0 /* Go through the edges and add all nodes that have light to light_sources @@ -3313,15 +3343,15 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->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]; + MapNode *n = &data->vmanip.m_data[i]; if(n->getLight(LIGHTBANK_DAY) != 0) { light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); @@ -3368,17 +3398,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Loop from top to down { u8 light = LIGHT_SUN; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->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]; + MapNode *n = &data->vmanip.m_data[i]; if(light_propagates_content(n->d) == false) { light = 0; @@ -3400,19 +3430,19 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Increment index by y - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } #endif - /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + /*for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; x++) - for(s16 z=0-max_spread_amount+1; - zmax_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; z++)*/ #if 1 /* @@ -3427,7 +3457,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); /* Apply initial sunlight @@ -3435,12 +3465,12 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { u8 light = LIGHT_SUN; bool add_to_sources = false; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->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]; + MapNode *n = &data->vmanip.m_data[i]; if(light_propagates_content(n->d) == false) { @@ -3470,8 +3500,8 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { v3s16 dirp = dirs4[di]; u32 i2 = i; - vmanip.m_area.add_p(em, i2, dirp); - MapNode *n2 = &vmanip.m_data[i2]; + data->vmanip.m_area.add_p(em, i2, dirp); + MapNode *n2 = &data->vmanip.m_data[i2]; if( n2->d != CONTENT_AIR && n2->d != CONTENT_WATERSOURCE @@ -3494,58 +3524,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Increment index by y - vmanip.m_area.add_y(em, i, -1); - } - } - } -#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); + data->vmanip.m_area.add_y(em, i, -1); } } } @@ -3555,8 +3534,8 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Spread light around { - TimeTaker timer("generateChunkRaw() spreadLight"); - vmanip.spreadLight(LIGHTBANK_DAY, light_sources); + TimeTaker timer("makeChunk() spreadLight"); + data->vmanip.spreadLight(LIGHTBANK_DAY, light_sources); } /* @@ -3564,14 +3543,137 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ timer_generate.stop(); +} - /* - Blit generated stuff to map - */ +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### + +void ServerMap::initChunkMake(ChunkMakeData &data, v2s16 chunkpos) +{ + if(m_chunksize == 0) + { + data.no_op = true; + return; + } + + data.no_op = false; + + // 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; + + s16 y_blocks_min = -4; + s16 y_blocks_max = 3; + + v2s16 sectorpos_base = chunk_to_sector(chunkpos); + s16 sectorpos_base_size = m_chunksize; + + v2s16 sectorpos_bigbase = + sectorpos_base - v2s16(1,1) * max_spread_amount_sectors; + s16 sectorpos_bigbase_size = + sectorpos_base_size + 2 * max_spread_amount_sectors; + + data.seed = m_seed; + data.chunkpos = chunkpos; + data.y_blocks_min = y_blocks_min; + data.y_blocks_max = y_blocks_max; + data.sectorpos_base = sectorpos_base; + data.sectorpos_base_size = sectorpos_base_size; + data.sectorpos_bigbase = sectorpos_bigbase; + data.sectorpos_bigbase_size = sectorpos_bigbase_size; + data.max_spread_amount = max_spread_amount; + + /* + Create the whole area of this and the neighboring chunks + */ + { + TimeTaker timer("initChunkMake() create area"); + + for(s16 x=0; xsetLightingExpired(true); + // Lighting will be calculated + block->setLightingExpired(false); + + /* + Block gets sunlight if this is true. + + This should be set to true when the top side of a block + is completely exposed to the sky. + + Actually this doesn't matter now because the + initial lighting is done here. + */ + block->setIsUnderground(y != y_blocks_max); + } + } + } + + /* + Now we have a big empty area. + + Make a ManualMapVoxelManipulator that contains this and the + neighboring chunks + */ + + v3s16 bigarea_blocks_min( + sectorpos_bigbase.X, + y_blocks_min, + sectorpos_bigbase.Y + ); + v3s16 bigarea_blocks_max( + sectorpos_bigbase.X + sectorpos_bigbase_size - 1, + y_blocks_max, + sectorpos_bigbase.Y + sectorpos_bigbase_size - 1 + ); + + data.vmanip.setMap(this); + // Add the area + { + TimeTaker timer("initChunkMake() initialEmerge"); + data.vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); + } + +} + +MapChunk* ServerMap::finishChunkMake(ChunkMakeData &data, + core::map &changed_blocks) +{ + if(data.no_op) + return NULL; + + /* + Blit generated stuff to map + */ { // 70ms @cs=8 //TimeTaker timer("generateChunkRaw() blitBackAll"); - vmanip.blitBackAll(&changed_blocks); + data.vmanip.blitBackAll(&changed_blocks); } /* @@ -3586,7 +3688,35 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } } - + /* + Copy transforming liquid information + */ + while(data.transforming_liquid.size() > 0) + { + v3s16 p = data.transforming_liquid.pop_front(); + m_transforming_liquid.push_back(p); + } + + /* + Add random objects to blocks + */ + { + for(s16 x=0; xsetIsVolatile(false); @@ -3620,6 +3750,49 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Save changed parts of map */ save(true); + + return chunk; +} + +#if 0 +// NOTE: Deprecated +MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, + core::map &changed_blocks, + bool force) +{ + DSTACK(__FUNCTION_NAME); + + /* + Don't generate if already fully generated + */ + if(force == false) + { + MapChunk *chunk = getChunk(chunkpos); + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + { + dstream<<"generateChunkRaw(): Chunk " + <<"("< &changed_blocks) { @@ -3652,10 +3826,11 @@ MapChunk* ServerMap::generateChunk(v2s16 chunkpos1, MapChunk *chunk = getChunk(chunkpos1); return chunk; } +#endif ServerMapSector * ServerMap::createSector(v2s16 p2d) { - DSTACK("%s: p2d=(%d,%d)", + DSTACKF("%s: p2d=(%d,%d)", __FUNCTION_NAME, p2d.X, p2d.Y); @@ -3706,6 +3881,7 @@ ServerMapSector * ServerMap::createSector(v2s16 p2d) return sector; } +#if 0 MapSector * ServerMap::emergeSector(v2s16 p2d, core::map &changed_blocks) { @@ -3756,13 +3932,43 @@ MapSector * ServerMap::emergeSector(v2s16 p2d, /* generateChunk should have generated the sector */ - assert(0); + //assert(0); + + dstream<<"WARNING: ServerMap::emergeSector: Cannot find sector (" + < &lighting_invalidated_blocks ) { - DSTACK("%s: p=(%d,%d,%d)", + DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z); + + // If chunks are disabled + /*if(m_chunksize == 0) + { + dstream<<"ServerMap::generateBlock(): Chunks disabled -> " + <<"not generating."<unDummify(); } +#if 0 + /* + Generate a completely empty block + */ + for(s16 z0=0; z0setNode(v3s16(x0,y0,z0), n); + } + } +#else + /* + Generate a proper block + */ + u8 water_material = CONTENT_WATERSOURCE; s32 lowest_ground_y = 32767; @@ -3826,14 +4060,22 @@ MapBlock * ServerMap::generateBlock( { //dstream<<"generateBlock: x0="<getNode(v3s16(x0,y0,z0)); - // Create dungeons + // Create caves if(underground_emptiness[ ued*ued*(z0*ued/MAP_BLOCKSIZE) +ued*(y0*ued/MAP_BLOCKSIZE) @@ -4194,7 +4436,7 @@ MapBlock * ServerMap::generateBlock( if(content_features(n.d).walkable/*is_ground_content(n.d)*/) { // Has now caves - has_dungeons = true; + has_caves = true; // Set air to node n.d = CONTENT_AIR; } @@ -4214,7 +4456,7 @@ MapBlock * ServerMap::generateBlock( Force lighting update if some part of block is partly underground and has caves. */ - /*if(some_part_underground && !completely_underground && has_dungeons) + /*if(some_part_underground && !completely_underground && has_caves) { //dstream<<"Half-ground caves"<getPos()] = block; @@ -4339,11 +4581,13 @@ MapBlock * ServerMap::generateBlock( //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); } } } + +#endif // end of proper block generation /* Add block to sector. @@ -4359,11 +4603,11 @@ MapBlock * ServerMap::generateBlock( */ dstream <<"lighting_invalidated_blocks.size()" - <<", has_dungeons" + <<", has_caves" <<", completely_ug" <<", some_part_ug" <<" "< 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; /* @@ -4391,17 +4646,22 @@ MapBlock * ServerMap::createBlock(v3s16 p) sector = (ServerMapSector*)createSector(p2d); assert(sector->getId() == MAPSECTOR_SERVER); } - /*catch(InvalidPositionException &e) + catch(InvalidPositionException &e) { dstream<<"createBlock: createSector() failed"< &lighting_invalidated_blocks ) { - DSTACK("%s: p=(%d,%d,%d), only_from_disk=%d", + DSTACKF("%s: p=(%d,%d,%d), only_from_disk=%d", __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: " <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 + */ + // This won't work if proper generation is disabled + if(m_chunksize == 0) + return WATER_LEVEL+2; + double level = base_rock_level_2d(m_seed, p2d) + AVERAGE_MUD_AMOUNT; + return (s16)level; +} + +void ServerMap::createDirs(std::string path) { - if(fs::CreateDir(path) == false) + if(fs::CreateAllDirs(path) == false) { m_dout<::Iterator i = m_sectors.getIterator(); for(; i.atEnd() == false; i++) @@ -4661,6 +5026,8 @@ void ServerMap::save(bool only_changed) } } +#if 0 +// NOTE: Doing this is insane. Deprecated and probably broken. void ServerMap::loadAll() { DSTACK(__FUNCTION_NAME); @@ -4673,7 +5040,7 @@ void ServerMap::loadAll() dstream<serialize(os, version); } + + setChunksNonModified(); } void ServerMap::loadChunkMeta() @@ -4916,35 +5290,54 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector) u8 version = SER_FMT_VER_HIGHEST; // Get destination v2s16 pos = sector->getPos(); - createDir(m_savedir); - createDir(m_savedir+"/sectors"); std::string dir = getSectorDir(pos); - createDir(dir); + createDirs(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); sector->differs_from_disk = false; } -MapSector* ServerMap::loadSectorMeta(std::string dirname) +MapSector* ServerMap::loadSectorMeta(std::string sectordir, bool save_after_load) { DSTACK(__FUNCTION_NAME); // Get destination - v2s16 p2d = getSectorPos(dirname); - std::string dir = m_savedir + "/sectors/" + dirname; - - std::string fullpath = dir + "/heightmap"; + v2s16 p2d = getSectorPos(sectordir); + + ServerMapSector *sector = NULL; + + std::string fullpath = sectordir + "/meta"; std::ifstream is(fullpath.c_str(), std::ios_base::binary); if(is.good() == false) - throw FileNotGoodException("Cannot open sector heightmap"); - - ServerMapSector *sector = ServerMapSector::deSerialize - (is, this, p2d, m_sectors); + { + // If the directory exists anyway, it probably is in some old + // format. Just go ahead and create the sector. + if(fs::PathExists(sectordir)) + { + dstream<<"ServerMap::loadSectorMeta(): Sector metafile " + <differs_from_disk = false; @@ -4954,14 +5347,31 @@ MapSector* ServerMap::loadSectorMeta(std::string dirname) bool ServerMap::loadSectorFull(v2s16 p2d) { DSTACK(__FUNCTION_NAME); - std::string sectorsubdir = getSectorSubDir(p2d); MapSector *sector = NULL; - JMutexAutoLock lock(m_sector_mutex); + // The directory layout we're going to load from. + // 1 - original sectors/xxxxzzzz/ + // 2 - new sectors2/xxx/zzz/ + // If we load from anything but the latest structure, we will + // immediately save to the new one, and remove the old. + int loadlayout = 1; + std::string sectordir1 = getSectorDir(p2d, 1); + std::string sectordir; + if(fs::PathExists(sectordir1)) + { + sectordir = sectordir1; + } + else + { + loadlayout = 2; + sectordir = getSectorDir(p2d, 2); + } + + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out try{ - sector = loadSectorMeta(sectorsubdir); + sector = loadSectorMeta(sectordir, loadlayout != 2); } catch(InvalidFilenameException &e) { @@ -4975,9 +5385,12 @@ bool ServerMap::loadSectorFull(v2s16 p2d) { return false; } - + + /* + Load blocks + */ std::vector list2 = fs::GetDirListing - (m_savedir+"/sectors/"+sectorsubdir); + (sectordir); std::vector::iterator i2; for(i2=list2.begin(); i2!=list2.end(); i2++) { @@ -4985,38 +5398,24 @@ bool ServerMap::loadSectorFull(v2s16 p2d) if(i2->dir) continue; try{ - loadBlock(sectorsubdir, i2->name, sector); + loadBlock(sectordir, i2->name, sector, loadlayout != 2); } catch(InvalidFilenameException &e) { // This catches unknown crap in directory } } - 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) + if(loadlayout != 2) { - /* - Try to load the sector from disk. - */ - if(loadSectorFull(p2d) == true) - { - return true; - } + dstream<<"Sector converted to new layout - deleting "<< + sectordir1<getPos(); v2s16 p2d(p3d.X, p3d.Z); - createDir(m_savedir); - createDir(m_savedir+"/sectors"); std::string dir = getSectorDir(p2d); - createDir(dir); + createDirs(dir); - // Block file is map/sectors/xxxxxxxx/xxxx char cc[5]; snprintf(cc, 5, "%.4x", (unsigned int)p3d.Y&0xffff); std::string fullpath = dir + "/" + cc; @@ -5066,104 +5462,104 @@ void ServerMap::saveBlock(MapBlock *block) block->serializeObjects(o, version); } + /* + Versions up from 15 have static objects. + */ + if(version >= 15) + { + block->m_static_objects.serialize(o); + } + // We just wrote it to the disk block->resetChangedFlag(); } -void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector) +void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSector *sector, bool save_after_load) { DSTACK(__FUNCTION_NAME); + std::string fullpath = sectordir+"/"+blockfile; 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"); + 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); + if(is.fail()) + throw SerializationError("ServerMap::loadBlock(): Failed" + " to read MapBlock version"); - /*u32 block_size = MapBlock::serializedLength(version); - SharedBuffer data(block_size); - is.read((char*)*data, block_size);*/ + /*u32 block_size = MapBlock::serializedLength(version); + SharedBuffer data(block_size); + is.read((char*)*data, block_size);*/ - // This will always return a sector because we're the server - //MapSector *sector = emergeSector(p2d); + // This will always return a sector because we're the server + //MapSector *sector = emergeSector(p2d); - 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); - } + 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); + } - if(created_new) - sector->insertBlock(block); - - /* - Convert old formats to new and save - */ + /* + Versions up from 15 have static objects. + */ + if(version >= 15) + { + block->m_static_objects.deSerialize(is); + } + + 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(); + // Save old format blocks in new format + if(version < SER_FMT_VER_HIGHEST || save_after_load) + { + saveBlock(block); + } + + // We just loaded it from the disk, so it's up-to-date. + block->resetChangedFlag(); } catch(SerializationError &e) { dstream<<"WARNING: Invalid block data on disk " - "(SerializationError). Ignoring." + "(SerializationError). Ignoring. " + "A new one will be generated." <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);*/ + // TODO: Backup file; name is in fullpath. + } } void ServerMap::PrintInfo(std::ostream &out) @@ -5187,20 +5583,15 @@ ClientMap::ClientMap( 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(0,0,0, - map->getW()*BS, map->getH()*BS, map->getD()*BS);*/ - /*m_box = core::aabbox3d(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(-BS*1000000,-BS*1000000,-BS*1000000, BS*1000000,BS*1000000,BS*1000000); - - //setPosition(v3f(BS,BS,BS)); } ClientMap::~ClientMap() @@ -5225,11 +5616,11 @@ MapSector * ClientMap::emergeSector(v2s16 p2d) { } - // Create a sector with no heightmaps + // Create a sector ClientMapSector *sector = new ClientMapSector(this, p2d); { - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out m_sectors.insert(p2d, sector); } @@ -5241,7 +5632,7 @@ void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is) DSTACK(__FUNCTION_NAME); ClientMapSector *sector = NULL; - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out core::map::Node *n = m_sectors.find(p2d); @@ -5254,7 +5645,7 @@ void ClientMap::deSerializeSector(v2s16 p2d, std::istream &is) { sector = new ClientMapSector(this, p2d); { - JMutexAutoLock lock(m_sector_mutex); + //JMutexAutoLock lock(m_sector_mutex); // Bulk comment-out m_sectors.insert(p2d, sector); } } @@ -5288,7 +5679,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) */ 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; @@ -5390,10 +5781,18 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) { 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; @@ -5430,28 +5829,12 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) 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 @@ -5595,6 +5978,114 @@ bool ClientMap::clearTempMod(v3s16 p, return changed; } +void ClientMap::expireMeshes(bool only_daynight_diffed) +{ + TimeTaker timer("expireMeshes()"); + + core::map::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; jupdateMesh(daynight_ratio); + } +} +#endif + void ClientMap::PrintInfo(std::ostream &out) { out<<"ClientMap: "; @@ -5752,7 +6243,8 @@ void MapVoxelManipulator::blitBack } ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map): - MapVoxelManipulator(map) + MapVoxelManipulator(map), + m_create_area(false) { }