X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=fc674d263642bf05e2627cd6f5e13e2cedbf5e9e;hb=ccc0420c52d341ea20ff879aac7520179ca24bdf;hp=651bece4f35f191908da0460edb0efc52552d6de;hpb=bc66bb2d409f13554bdcec7386766af82a343cad;p=minetest.git diff --git a/src/map.cpp b/src/map.cpp index 651bece4f..fc674d263 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 @@ -36,8 +37,8 @@ Map::Map(std::ostream &dout): m_dout(dout), m_sector_cache(NULL) { - m_sector_mutex.Init(); - assert(m_sector_mutex.IsInitialized()); + /*m_sector_mutex.Init(); + assert(m_sector_mutex.IsInitialized());*/ } Map::~Map() @@ -103,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); } @@ -183,9 +184,6 @@ bool Map::isNodeUnderground(v3s16 p) light_sources to re-light the area without the removed light. values of from_nodes are lighting values. - - There is a duplicate implementation of this in VoxelManipulator, - which is faster for large volumes */ void Map::unspreadLight(enum LightBank bank, core::map & from_nodes, @@ -369,9 +367,6 @@ void Map::unLightNeighbors(enum LightBank bank, /* Lights neighbors of from_nodes, collects all them and then goes on recursively. - - There is a duplicate implementation of this in VoxelManipulator, - which is faster for large volumes */ void Map::spreadLight(enum LightBank bank, core::map & from_nodes, @@ -612,13 +607,13 @@ s16 Map::propagateSunlight(v3s16 start, } else { - // Turn mud into grass + /*// Turn mud into grass if(n.d == CONTENT_MUD) { n.d = CONTENT_GRASS; block->setNode(relpos, n); modified_blocks.insert(blockpos, block); - } + }*/ // Sunlight goes no further break; @@ -843,11 +838,6 @@ void Map::updateLighting(core::map & a_blocks, } /* - This is called after changing a node from transparent to opaque. - The lighting value of the node should be left as-is after changing - other values. This sets the lighting value to 0. - - NOTE: This takes almost no time, the slow one is updateMeshes. */ void Map::addNodeAndUpdate(v3s16 p, MapNode n, core::map &modified_blocks) @@ -884,12 +874,12 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, catch(InvalidPositionException &e) { } - + +#if 1 /* - If the new node doesn't propagate sunlight and there is - grass below, change it to mud + If the new node is solid and there is grass below, change it to mud */ - if(content_features(n.d).sunlight_propagates == false) + if(content_features(n.d).walkable == true) { try{ MapNode bottomnode = getNode(bottompos); @@ -905,7 +895,9 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, { } } +#endif +#if 0 /* If the new node is mud and it is under sunlight, change it to grass @@ -914,6 +906,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, { n.d = CONTENT_GRASS; } +#endif /* Remove all light that has come out of this node @@ -948,20 +941,40 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, 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--){ @@ -989,7 +1002,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, break; } } - + for(s32 i=0; i<2; i++) { enum LightBank bank = banks[i]; @@ -1044,7 +1057,6 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, } /* - NOTE: This takes almost no time, the slow one is updateMeshes. */ void Map::removeNodeAndUpdate(v3s16 p, core::map &modified_blocks) @@ -1093,6 +1105,12 @@ void Map::removeNodeAndUpdate(v3s16 p, light_sources, modified_blocks); } + /* + Remove node metadata + */ + + removeNodeMetadata(p); + /* Remove the node. This also clears the lighting. @@ -1329,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; @@ -1379,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(); @@ -1431,9 +1449,6 @@ void Map::transformLiquids(core::map & modified_blocks) while(m_transforming_liquid.size() != 0) { - try - { - /* Get a queued transforming liquid node */ @@ -1692,14 +1707,83 @@ void Map::transformLiquids(core::map & modified_blocks) } loopcount++; - if(loopcount >= initial_size * 1 || loopcount >= 1000) + //if(loopcount >= 100000) + if(loopcount >= initial_size * 1) break; - - }catch(InvalidPositionException &e) + } + //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; } } - //dstream<<"Map::transformLiquids(): loopcount="< & modified_blocks) ServerMap::ServerMap(std::string savedir): Map(dout_server), - m_seed(0) + m_seed(0), + m_map_metadata_changed(true) { - // TODO: Save to and load from a file + dstream<<__FUNCTION_NAME<::Iterator i = m_chunks.getIterator(); + for(; i.atEnd() == false; i++) + { + MapChunk *chunk = i.getNode()->getValue(); + delete chunk; + } } /* @@ -1863,11 +1978,8 @@ void make_tree(VoxelManipulator &vmanip, v3s16 p0) { MapNode treenode(CONTENT_TREE); MapNode leavesnode(CONTENT_LEAVES); - leavesnode.setLight(LIGHTBANK_DAY, LIGHT_MAX-1); - vmanip.emerge(VoxelArea(p0-v3s16(2,0,2),p0+v3s16(2,7+2,2))); - - s16 trunk_h = myrand_range(4, 7); + s16 trunk_h = myrand_range(3, 6); v3s16 p1 = p0; for(s16 ii=0; ii>32)+654879876, 6, 0.6); + + /*// A bit hillier one + double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + (seed>>27)+90340, 6, 0.69); + if(base2 > base) + base = base2;*/ +#if 1 + // Higher ground level + double higher = (double)WATER_LEVEL + 25. + 35. * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + seed+85039, 5, 0.69); + //higher = 30; // For debugging -bool get_have_sand_coast(u64 seed, v2f p) -{ - double sandnoise = noise2d_perlin( - 0.5+(float)p.X/250, 0.5+(float)p.Y/250, - seed+59420, 3, 0.50); - return (sandnoise > -0.25); -} + // Limit higher to at least base + if(higher < base) + higher = base; + + // Steepness factor of cliffs + double b = 1.0 + 1.0 * noise2d_perlin( + 0.5+(float)p.X/250., 0.5+(float)p.Y/250., + seed-932, 7, 0.7); + b = rangelim(b, 0.0, 1000.0); + b = pow(b, 5); + b *= 7; + b = rangelim(b, 3.0, 1000.0); + //dstream<<"b="< 1.0); + //dstream<<"a="<0, 0->1, 1->0 -double contour(double v) +double get_mud_add_amount(u64 seed, v2s16 p) { - v = fabs(v); - if(v >= 1.0) - return 0.0; - return (1.0-v); + 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)); } -// -1->0, -r->1, 0->1, r->1, 1->0 -double contour_flat_top(double v, double r) +/* + Adds random objects to block, depending on the content of the block +*/ +void addRandomObjects(MapBlock *block) { - v = fabs(v); - if(v >= 1.0) - return 0.0; - double rmax = 0.999; - if(r >= rmax) - r = rmax; - if(v <= r) - return 1.0; - v -= r; - return ((1.0-r)-v) / (1.0-r); - //return easeCurve(((1.0-r)-v) / (1.0-r)); + for(s16 z0=0; z0getNodeNoEx(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(); } -double base_rock_level_2d(u64 seed, v2f p) +#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1 + +/* + This is the main map generation method +*/ + +void makeChunk(ChunkMakeData *data) { - // The ground level (return value) - double h = WATER_LEVEL-1.5; - - // Raises from 0 when parameter is -1...1 - /*double m2 = contour_flat_top(-0.8 + 2.0 * noise2d_perlin( - 0.0+(float)p.X/1500., 0.0+(float)p.Y/1500., - (seed>>32)+34758, 5, 0.55), 0.10);*/ - /*double m2 = 1.0; - if(m2 > 0.0001) - { - // HUGE mountains - double m1 = 200.0 + 300.0 * noise2d_perlin( - 0.0+(float)p.X/1000., 0.0+(float)p.Y/1000., - (seed>>32)+98525, 8, 0.5); - h += m1 * m2; - //h += 30 * m2; - }*/ + if(data->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( + data->sectorpos_bigbase.X, + data->y_blocks_min, + data->sectorpos_bigbase.Y + ); + v3s16 bigarea_blocks_max( + data->sectorpos_bigbase.X + data->sectorpos_bigbase_size - 1, + data->y_blocks_max, + data->sectorpos_bigbase.Y + data->sectorpos_bigbase_size - 1 + ); + s16 lighting_min_d = 0-data->max_spread_amount; + s16 lighting_max_d = data->sectorpos_base_size*MAP_BLOCKSIZE + + data->max_spread_amount-1; - /*double tm2 = contour_flat_top(-1.0 + 3.0 * noise2d_perlin( - 0.0+(float)p.X/300., 0.0+(float)p.Y/300., - (seed>>32)+78593, 5, 0.55), 0.15); - h += 30 * tm2;*/ + // Clear all flags + data->vmanip.clearFlag(0xff); -#if 0 - { - // Large mountains - double m3 = 100.0 - 600.0 * noise2d_perlin_abs( - 0.324+(float)p.X/2000., 0.423+(float)p.Y/2000., - (seed>>32)+985251, 9, 0.55); - if(m3 > h) - h = m3; - } -#endif + TimeTaker timer_generate("makeChunk() generate"); -#if 0 - { - // More mountain ranges - double d = 100; - double a1 = d*2.0 - d*7 * noise2d_perlin_abs( - 0.5+(float)p.X/1000., 0.5+(float)p.Y/1000., - seed+850342, 7, 0.55); - /*if(a1 > d) - a1 = d + sqrt(a1-d);*/ - a1 = (1.0 - exp(-a1/d))*d; - /*if(a1 > h) - h = a1;*/ - if(a1 > 0) - h += a1; - } -#endif + // Maximum height of the stone surface and obstacles. + // This is used to disable cave generation from going too high. + s16 stone_surface_max_y = 0; -#if 0 + /* + Generate general ground level to full area + */ { - // More mountain ranges - double d = 60; - double a1 = d*2.0 - d*7 * noise2d_perlin_abs( - 0.5+(float)p.X/1000., 0.5+(float)p.Y/1000., - seed+850342, 7, 0.55); - /*if(a1 > d) - a1 = d + sqrt(a1-d);*/ - a1 = (1.0 - exp(-a1/d))*d; - /*if(a1 > h) - h = a1;*/ - if(a1 > 0) - h += a1; - } -#endif + // 22ms @cs=8 + TimeTaker timer1("Generating ground level"); #if 0 + NoiseBuffer noisebuf1; + //NoiseBuffer noisebuf2; { - // Very steep mountain ranges - double d = 120; - double a1 = d*2 - d*6.5 * noise2d_perlin_abs( - 0.5+(float)p.X/500., 0.5+(float)p.Y/500., - seed+850342, 6, 0.6); - /*if(a1 > d) - a1 = d + sqrt(a1-d);*/ - a1 = (1.0 - exp(-a1/d))*d; - /*if(a1 > h) - h = a1;*/ - if(a1 > 0) - h += a1; - /*double a = noise2d_perlin_abs( - 0.94+(float)p.X/2000., 0.26+(float)p.Y/2000., - (seed>>32)+65012102, 8, 0.50); - double m4 = 100.0 - 400.0 * a; - if(m4 > h) - h = m4;*/ - } -#endif - - /* - The stuff before this comment is usually not used. - The stuff after this comment is usually used. - */ + 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); -#if 1 + 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++) { - // Mountains - double m4 = 1.0 - 3.0 * noise2d_perlin_abs( - 0.324+(float)p.X/1000., 0.423+(float)p.Y/1000., - (seed>>32)+65012102, 8, 0.57); - m4 *= 120; - if(m4 > h) - h = m4; - } -#endif + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + // Ground height at this point + float surface_y_f = 0.0; -#if 1 - // Some kind of hill chains or something - { - double a1 = 1.0 - 2.5 * noise2d_perlin_abs( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed+850342, 5, 0.6); - a1 *= 30; - double d = 15; - if(a1 > d) - a1 = d + sqrt(a1-d); - /*if(a1 > h) - h = a1;*/ - if(a1 > 0) - h += a1; - } -#endif + // 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; -#if 1 - double base = -2. + 25. * noise2d_perlin( - 0.5+(float)p.X/500., 0.5+(float)p.Y/500., - (seed>>32)+653876, 7, 0.65); -#else - double base = 0; + /* + 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; + + /*s16 noiseval = 50.0 * noise3d_perlin( + 0.5+(float)p2d.X/100.0, + 0.5+(float)y/100.0, + 0.5+(float)p2d.Y/100.0, + data->seed+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 - /* - Combined with turbulence, this thing here is able to make very - awesome terrain, albeit rarely. - - This is also responsible for small islands. - */ - - double higher = 40. * noise2d_perlin( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed+39292, 6, 0.50); - /*double higher = 50. * noise2d_perlin_abs( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed+85039, 5, 0.63);*/ - //higher = 25; - - if(higher > base) + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) { - // Steepness factor of cliffs - double b = 1.0 + 1.0 * noise2d_perlin( - 0.5+(float)p.X/250., 0.5+(float)p.Y/250., - seed-932, 6, 0.7); - b = rangelim(b, 0.0, 1000.0); -#if 1 - b = pow(b, 5); - b *= 16; - b = rangelim(b, 3.0, 1000.0); - //dstream<<"b="<sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Skip of already generated + */ + /*{ + v3s16 p(p2d.X, y_nodes_min, p2d.Y); + if(data->vmanip.m_data[data->vmanip.m_area.index(p)].d != CONTENT_AIR) + continue; + }*/ - //dstream<<"a="< h) - h = h2;*/ + // Use perlin noise for ground height + surface_y_f = base_rock_level_2d(data->seed, p2d); - h += base*(1.0-a) + higher*a; - } - else - { - h += base; - } -#else - h += base; -#endif - - return h; -} - -double base_rock_level_2d(u64 seed, v2s16 p) -{ - return base_rock_level_2d(seed, v2f((float)p.X, (float)p.Y)); -} - -double get_turbulence_factor_2d(u64 seed, v2f p) -{ - double vv = -0.50 + 2.0 * noise2d_perlin( - 0.5+p.X/100, - 0.5+p.Y/100, - seed+85498783983, 4, 0.5); - vv = rangelim(vv, 0.0, 1.0); - return vv; -} - -#define TURBULENCE_BOTTOM_CUTOFF_Y (WATER_LEVEL-7) - -double get_turbulence_factor_y(u64 seed, f32 y) -{ - double d = 14; - double min = TURBULENCE_BOTTOM_CUTOFF_Y; - if(y < min) - return 0.0; - else if(y < min + d) - return ((y-min)/d); - return 1.0; -} - -v2f get_raw_turbulence(u64 seed, v3f p) -{ - double f = 8; - - double v1 = f * noise3d_perlin( - 0.5+p.X/100, - 0.5+p.Y/100, - 0.5+p.Z/100, - seed+4045, 5, 0.65); - - double v2 = f * noise3d_perlin( - 0.5+p.X/100, - 0.5+p.Y/100, - 0.5+p.Z/100, - seed+9495, 5, 0.65); - - return v2f(v1, v2); -} + /*// Experimental stuff + { + float a = highlands_level_2d(data->seed, p2d); + if(a > surface_y_f) + surface_y_f = a; + }*/ -// Shouldn't be used, provided for compatibility. -v2f base_ground_turbulence(u64 seed, v3f p) -{ - double tfxz = get_turbulence_factor_2d(seed, v2f(p.X,p.Z)); - double tfy = get_turbulence_factor_y(seed, p.Y); - v2f t = get_raw_turbulence(seed, p); - return t*tfxz*tfy; -} + // 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; -#if 0 -v2f base_ground_turbulence(u64 seed, v3f p) -{ -#if 1 - double f = 8; + /* + 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; yvmanip.m_data[i].d != CONTENT_AIR) + break; -#if 1 - // Cut off at a minimum height - { - double d = 15; - double min = WATER_LEVEL-5; - if(p.Y < min) - return v2f(0,0); - else if(p.Y < min + d) - f *= ((p.Y-min)/d); - } -#endif + data->vmanip.m_data[i].d = CONTENT_STONE; -#if 1 - double vv = 0.50 + 1.0 * noise3d_perlin( - 0.5+p.X/250, - 0.5+p.Y/250, - 0.5+p.Z/250, - seed+1324381, 4, 0.5); - double vve = rangelim(vv, 0.0, 1.0); - /*double vv = 1.0 - 2.0 * noise3d_perlin_abs( - 0.5+p.X/250, - 0.5+p.Y/250, - 0.5+p.Z/250, - seed+1324031, 4, 0.5); - double vve = 1.0 - exp(-MYMAX(0, vv*2.0));*/ - //double vve = rangelim(vv, 0, 1.0); - //dstream<<"vve="< ah) - { - vve *= p.Y/ah; + data->vmanip.m_area.add_y(em, i, 1); + } + } } -#else - double vve = 1; #endif - - double v1 = f * noise3d_perlin( - 0.5+p.X/100, - 0.5+p.Y/100, - 0.5+p.Z/100, - seed+4045, 5, 0.65); - - double v2 = f * noise3d_perlin( - 0.5+p.X/100, - 0.5+p.Y/100, - 0.5+p.Z/100, - seed+9495, 5, 0.65); - return v2f(v1*vve, v2*vve); -#else - return v2f(0,0); -#endif -} -#endif - -bool is_carved(u64 seed, v3f p) -{ -#if 1 - double v1 = noise3d_perlin_abs( - 0.5+p.X/200, - 0.5+p.Y/200, - 0.5+p.Z/200, - seed+657890854, 5, 0.7); - - if(v1 > 1.45) - return true; -#endif + }//timer1 - double f = 10.0; - double y_div = 1.0; - - double v4 = contour(f*noise3d_perlin( - 0.5+p.X/200, - 0.5+p.Y/200*y_div, - 0.5+p.Z/200, - seed+87592, 5, 0.7)); - // Tilted 90 degrees - double v5 = contour(f*noise3d_perlin( - 0.5+p.X/200, - 0.5+p.Z/200, - 0.5+p.Y/200*y_div, - seed+98594, 5, 0.7)); - - double v45 = v4*v5; - if(v45 > 2.5/f) - return true; + /* + Randomize some parameters + */ - return false; -} - -bool is_underground_mud(u64 seed, v3f p) -{ - double v1 = noise3d_perlin_abs( - 0.5+p.X/50, - 0.5+p.Y/50, - 0.5+p.Z/50, - seed+83401, 5, 0.75); - return (v1 > 1.3); -} + //s32 stone_obstacle_count = 0; + /*s32 stone_obstacle_count = + rangelim((1.0+noise2d(data->seed+897, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ -/* - if depth_guess!=NULL, it is set to a guessed value of how deep - underground the position is. -*/ -bool is_base_ground(u64 seed, v3f p, double *depth_guess=NULL) -{ -#if 0 - // This is used for testing the output of the cave function - { - if(depth_guess) - *depth_guess = 10; - if(p.Y > 50) - return false; - return is_carved(seed, p); - } -#endif -#if 0 - // This is used for testing the output of the underground mud function - { - if(depth_guess) - *depth_guess = 10; - if(p.Y > 50) - return false; - return is_underground_mud(seed, p); - } -#endif + //s16 stone_obstacle_max_height = 0; + /*s16 stone_obstacle_max_height = + rangelim((1.0+noise2d(data->seed+5902, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ - bool is_ground = true; + /* + Loop this part, it will make stuff look older and newer nicely + */ + const u32 age_loops = 2; + for(u32 i_age=0; i_age caves_count); -#if 0 - if(depth_guess) + if(bruise_surface) { - // Find highest surface near current - v3f dirs[4] = { - v3f(1,0,0), - v3f(-1,0,0), - v3f(0,0,1), - v3f(0,0,-1) - }; - double s2 = surface_y_f; - for(u32 i=0; i<4; i++) - { - v3f dir = dirs[i]; - // Get turbulence at around there - v2f t2 = base_ground_turbulence(seed, p+dir); - // Get ground height - v2f l = v2f(p.X+t2.X+dir.X, p.Z+t2.Y+dir.Z); - double s = base_rock_level_2d(seed, l); - if(s > s2) - s2 = s; - } - *depth_guess = s2 - p.Y; + min_tunnel_diameter = 5; + max_tunnel_diameter = myrand_range(10, 20); + /*min_tunnel_diameter = MYMAX(0, stone_surface_max_y/6); + max_tunnel_diameter = myrand_range(MYMAX(0, stone_surface_max_y/6), MYMAX(0, stone_surface_max_y/2));*/ + + /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(data->seed+42, + data->sectorpos_base.X, data->sectorpos_base.Y)), 0, 15);*/ + + tunnel_routepoints = 5; } -#endif -#if 1 - if(depth_guess) + else { - // Check a bit lower also, take highest surface - v2f t2 = base_ground_turbulence(seed, p + v3f(0,-2,0)); - double s2 = base_rock_level_2d(seed, v2f(p.X+t2.X, p.Z+t2.Y)); - if(s2 > surface_y_f) - *depth_guess = s2 - p.Y; - else - *depth_guess = surface_y_f - p.Y; } -#endif -#if 0 - if(depth_guess) - *depth_guess = surface_y_f - p.Y; -#endif - - if(p.Y > surface_y_f) - is_ground = false; - } - - /*if(depth_guess) - { - // Guess surface point - v3f p2(p.X, surface_y_f, p.Z); - v2f t2 = base_ground_turbulence - double u1 = - double s1 = base_rock_level_2d(seed, v2f(p.X+v1,p.Z+v2)); - }*/ - - return is_ground; -} -#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1 + // Allowed route area size in nodes + v3s16 ar( + data->sectorpos_base_size*MAP_BLOCKSIZE, + h_blocks*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE + ); -/* - This is the main map generation method -*/ + // Area starting point in nodes + v3s16 of( + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE + ); -#if 0 -MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, - core::map &changed_blocks, - bool force) -{ - DSTACK(__FUNCTION_NAME); + // 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 = data->max_spread_amount - max_tunnel_diameter/2 - insure; + ar += v3s16(1,0,1) * more * 2; + of -= v3s16(1,0,1) * more; + + s16 route_y_min = 0; + // Allow half a diameter + 7 over stone surface + s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7; - // Shall be not used now - //assert(0); + /*// If caves, don't go through surface too often + if(bruise_surface == false) + route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/ -#if 0 + // Limit maximum to area + route_y_max = rangelim(route_y_max, 0, ar.Y-1); - /* - Don't generate if already fully generated - */ - if(force == false) - { - MapChunk *chunk = getChunk(chunkpos); - if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + if(bruise_surface) { - dstream<<"generateChunkRaw(): Chunk " - <<"("<setLightingExpired(true); - // Lighting will be calculated - block->setLightingExpired(false); - - /* - Block gets sunlight if this is true. - - This should be set to true when the top side of a block - is completely exposed to the sky. - - Actually this doesn't matter now because the - initial lighting is done here. - */ - block->setIsUnderground(y != y_blocks_max); - } - } - } - - /* - Now we have a big empty area. - - Make a ManualMapVoxelManipulator that contains this and the - neighboring chunks - */ - - ManualMapVoxelManipulator vmanip(this); - // Add the area we just generated - { - TimeTaker timer("generateChunkRaw() initialEmerge"); - vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); - } - - // Clear all flags - vmanip.clearFlag(0xff); - - TimeTaker timer_generate("generateChunkRaw() generate"); - - // Maximum height of the stone surface and obstacles. - // This is used to disable dungeon generation from going too high. - s16 stone_surface_max_y = 0; - - /* - Generate general ground level to full area - */ - - { - // 22ms @cs=8 - TimeTaker timer1("ground level"); - dstream<<"Generating base ground..."< 0.0) - vmanip.m_data[i].d = CONTENT_STONE; - else - vmanip.m_data[i].d = CONTENT_AIR; -#endif -#if 0 - /*double v1 = 5 * noise3d_perlin( - 0.5+(float)p2df.X/200, - 0.5+(float)y/200, - 0.5+(float)p2df.Y/200, - m_seed+293, 6, 0.55); - - double v2 = 5 * noise3d_perlin( - 0.5+(float)p2df.X/200, - 0.5+(float)y/200, - 0.5+(float)p2df.Y/200, - m_seed+293, 6, 0.55);*/ - - double v1 = 0; - double v2 = 0; - - float surface_y_f = base_rock_level_2d(m_seed, p2df+v2f(v1,v2)); - - if(y <= surface_y_f) - vmanip.m_data[i].d = CONTENT_STONE; - else - vmanip.m_data[i].d = CONTENT_AIR; -#endif - - vmanip.m_area.add_y(em, i, 1); + maxlen = v3s16(rs*7,rs*7,rs*7); } - } - -#if 0 - // Node position - v2s16 p2d = sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); - - /* - Skip if already generated - */ - { - v3s16 p(p2d.X, y_nodes_min, p2d.Y); - if(vmanip.m_data[vmanip.m_area.index(p)].d != CONTENT_AIR) - continue; - } - - // Ground height at this point - float surface_y_f = 0.0; - - // Use perlin noise for ground height - surface_y_f = base_rock_level_2d(m_seed, p2d); - - /*// Experimental stuff - { - float a = highlands_level_2d(m_seed, p2d); - if(a > surface_y_f) - surface_y_f = a; - }*/ - - // Convert to integer - s16 surface_y = (s16)surface_y_f; - - // Log it - if(surface_y > stone_surface_max_y) - stone_surface_max_y = surface_y; - - /* - Fill ground with stone - */ - { - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); - for(s16 y=y_nodes_min; y=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; + 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 + ); } + + vec += main_direction; + v3f rp = orp + vec; + if(rp.X < 0) + rp.X = 0; + else if(rp.X >= ar.X) + rp.X = ar.X-1; + if(rp.Y < route_y_min) + rp.Y = route_y_min; + else if(rp.Y >= route_y_max) + rp.Y = route_y_max-1; + if(rp.Z < 0) + rp.Z = 0; + else if(rp.Z >= ar.Z) + rp.Z = ar.Z-1; + vec = rp - orp; - /* - Add stone on ground - */ + for(float f=0; f<1.0; f+=1.0/vec.getLength()) { - 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; + v3f fp = orp + vec * f; + v3s16 cp(fp.X, fp.Y, fp.Z); - 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++) + s16 d0 = -rs/2; + s16 d1 = d0 + rs - 1; + for(s16 z0=d0; z0<=d1; z0++) { - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_MUD; - count++; - if(count >= mud_amount) - break; - - vmanip.m_area.add_y(em, i, 1); + //s16 si = rs - MYMAX(0, abs(z0)-rs/4); + s16 si = rs - MYMAX(0, abs(z0)-rs/7); + for(s16 x0=-si; x0<=si-1; x0++) + { + s16 maxabsxz = MYMAX(abs(x0), abs(z0)); + //s16 si2 = rs - MYMAX(0, maxabsxz-rs/4); + s16 si2 = rs - MYMAX(0, maxabsxz-rs/7); + //s16 si2 = rs - abs(x0); + for(s16 y0=-si2+1+2; y0<=si2-1; y0++) + { + s16 z = cp.Z + z0; + s16 y = cp.Y + y0; + s16 x = cp.X + x0; + v3s16 p(x,y,z); + /*if(isInArea(p, ar) == false) + continue;*/ + // Check only height + if(y < 0 || y >= ar.Y) + continue; + p += of; + + //assert(data->vmanip.m_area.contains(p)); + if(data->vmanip.m_area.contains(p) == false) + { + dstream<<"WARNING: "<<__FUNCTION_NAME + <<":"<<__LINE__<<": " + <<"point not in area" + <vmanip.m_area.index(p); + data->vmanip.m_data[i] = airnode; + + if(bruise_surface == false) + { + // Set tunnel flag + data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; + } + } + } } } + orp = rp; } + } }//timer1 +#endif + +#if 1 { - // 24ms @cs=8 - //TimeTaker timer1("dungeons"); + // 46ms @cs=8 + //TimeTaker timer1("ore veins"); /* - Make dungeons + Make ore veins */ - u32 dungeons_count = relative_volume / 600000; - u32 bruises_count = relative_volume * stone_surface_max_y / 40000000; - if(stone_surface_max_y < WATER_LEVEL) - bruises_count = 0; - /*u32 dungeons_count = 0; - u32 bruises_count = 0;*/ - for(u32 jj=0; 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; @@ -3242,2383 +2800,559 @@ 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]; - if(n->d == CONTENT_STONE) - n->param = mineral; - } - } - } - } - - orp = rp; - } - - } - - }//timer1 - { - // 15ms @cs=8 - //TimeTaker timer1("add mud"); - - /* - Add mud to the central chunk - */ - - for(s16 x=0; xd == CONTENT_GRASS) - n->d = CONTENT_MUD; - } - - /* - Add mud on ground - */ - { - s16 mudcount = 0; - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = surface_y+1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - for(s16 y=y_start; y<=y_nodes_max; y++) - { - if(mudcount >= mud_add_amount) - break; - - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_MUD; - mudcount++; - - vmanip.m_area.add_y(em, i, 1); - } - } - - } - - }//timer1 - { - // 340ms @cs=8 - //TimeTaker timer1("flow mud"); - - /* - Flow mud away from steep edges - */ - - // Limit area by 1 because mud is flown into neighbors. - s16 mudflow_minpos = 0-max_spread_amount+1; - s16 mudflow_maxpos = sectorpos_base_size*MAP_BLOCKSIZE+max_spread_amount-2; - - // Iterate a few times - for(s16 k=0; k<3; k++) - { - - for(s16 x=mudflow_minpos; - x<=mudflow_maxpos; - x++) - for(s16 z=mudflow_minpos; - z<=mudflow_maxpos; - z++) - { - // Invert coordinates every 2nd iteration - if(k%2 == 0) - { - x = mudflow_maxpos - (x-mudflow_minpos); - z = mudflow_maxpos - (z-mudflow_minpos); - } - - // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); - s16 y=y_nodes_max; - - for(;; y--) - { - MapNode *n = NULL; - // Find mud - for(; y>=y_nodes_min; y--) - { - n = &vmanip.m_data[i]; - //if(content_walkable(n->d)) - // break; - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - break; - - vmanip.m_area.add_y(em, i, -1); - } - - // Stop if out of area - //if(vmanip.m_area.contains(i) == false) - if(y < y_nodes_min) - break; - - /*// If not mud, do nothing to it - MapNode *n = &vmanip.m_data[i]; - if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) - continue;*/ - - /* - Don't flow it if the stuff under it is not mud - */ - { - u32 i2 = i; - vmanip.m_area.add_y(em, i2, -1); - // Cancel if out of area - if(vmanip.m_area.contains(i2) == false) - continue; - MapNode *n2 = &vmanip.m_data[i2]; - if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS) - continue; - } - - // Make it exactly mud - n->d = CONTENT_MUD; - - /*s16 recurse_count = 0; - mudflow_recurse:*/ - - v3s16 dirs4[4] = { - v3s16(0,0,1), // back - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(-1,0,0), // left - }; - - // Theck that upper is air or doesn't exist. - // Cancel dropping if upper keeps it in place - u32 i3 = i; - vmanip.m_area.add_y(em, i3, 1); - if(vmanip.m_area.contains(i3) == true - && content_walkable(vmanip.m_data[i3].d) == true) - { - continue; - } - - // Drop mud on side - - for(u32 di=0; di<4; di++) - { - v3s16 dirp = dirs4[di]; - u32 i2 = i; - // Move to side - vmanip.m_area.add_p(em, i2, dirp); - // Fail if out of area - if(vmanip.m_area.contains(i2) == false) - continue; - // Check that side is air - MapNode *n2 = &vmanip.m_data[i2]; - if(content_walkable(n2->d)) - continue; - // Check that under side is air - vmanip.m_area.add_y(em, i2, -1); - if(vmanip.m_area.contains(i2) == false) - continue; - n2 = &vmanip.m_data[i2]; - if(content_walkable(n2->d)) - continue; - /*// Check that under that is air (need a drop of 2) - vmanip.m_area.add_y(em, i2, -1); - if(vmanip.m_area.contains(i2) == false) - continue; - n2 = &vmanip.m_data[i2]; - if(content_walkable(n2->d)) - continue;*/ - // Loop further down until not air - do{ - vmanip.m_area.add_y(em, i2, -1); - // Fail if out of area - if(vmanip.m_area.contains(i2) == false) - continue; - n2 = &vmanip.m_data[i2]; - }while(content_walkable(n2->d) == false); - // Loop one up so that we're in air - vmanip.m_area.add_y(em, i2, 1); - n2 = &vmanip.m_data[i2]; - - // Move mud to new place - *n2 = *n; - // Set old place to be air - *n = MapNode(CONTENT_AIR); - - // Done - break; - } - } - } - - } - - }//timer1 - { - // 50ms @cs=8 - //TimeTaker timer1("add water"); - - /* - Add water to the central chunk (and a bit more) - */ - - for(s16 x=0-max_spread_amount; - x WATER_LEVEL) - continue;*/ - - /* - Add water on ground - */ - { - v3s16 em = vmanip.m_area.getExtent(); - u8 light = LIGHT_MAX; - // Start at global water surface level - s16 y_start = WATER_LEVEL; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; - - /*// Add first one to transforming liquid queue, if water - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y_start, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ - - for(s16 y=y_start; y>=y_nodes_min; y--) - { - n = &vmanip.m_data[i]; - - // Stop when there is no water and no air - if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE - && n->d != CONTENT_WATER) - { - /*// Add bottom one to transforming liquid queue - vmanip.m_area.add_y(em, i, 1); - n = &vmanip.m_data[i]; - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ - - break; - } - - // Make water only not in dungeons - if(!(vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) - { - n->d = CONTENT_WATERSOURCE; - //n->setLight(LIGHTBANK_DAY, light); - - // Add to transforming liquid queue (in case it'd - // start flowing) - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - } - - // Next one - vmanip.m_area.add_y(em, i, -1); - if(light > 0) - light--; - } - } - - } - - }//timer1 - - } // Aging loop - - { - //TimeTaker timer1("convert mud to sand"); - - /* - Convert mud to sand - */ - - //s16 mud_add_amount = myrand_range(2, 4); - //s16 mud_add_amount = 0; - - /*for(s16 x=0; x WATER_LEVEL + 2) - continue; - - { - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = surface_y; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - u32 not_sand_counter = 0; - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - { - n->d = CONTENT_SAND; - } - else - { - not_sand_counter++; - if(not_sand_counter > 3) - break; - } - - vmanip.m_area.add_y(em, i, -1); - } - } - - } - - }//timer1 - { - // 1ms @cs=8 - //TimeTaker timer1("generate trees"); - - /* - Generate some trees - */ - { - // Divide area into parts - s16 div = 8; - s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; - double area = sidelen * sidelen; - for(s16 x0=0; x0d != CONTENT_MUD && n->d != CONTENT_GRASS) - continue; - } - p.Y++; - // Make a tree - make_tree(vmanip, p); - } - } - /*u32 tree_max = relative_area / 60; - //u32 count = myrand_range(0, tree_max); - for(u32 i=0; i=y_nodes_min; y--) - { - MapNode &n = vmanip.m_data[i]; - if(n.d != CONTENT_AIR - && n.d != CONTENT_LEAVES) - break; - vmanip.m_area.add_y(em, i, -1); - } - if(y >= y_nodes_min) - surface_y = y; - else - surface_y = y_nodes_min; - } - - u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); - MapNode *n = &vmanip.m_data[i]; - if(n->d == CONTENT_MUD) - n->d = CONTENT_GRASS; - } - - }//timer1 - - /* - Initial lighting (sunlight) - */ - - core::map light_sources; - - { - // 750ms @cs=8, can't optimize more - TimeTaker timer1("initial lighting"); - -#if 0 - /* - Go through the edges and add all nodes that have light to light_sources - */ - - // Four edges - for(s16 i=0; i<4; i++) - // Edge length - for(s16 j=lighting_min_d; - j<=lighting_max_d; - j++) - { - s16 x; - s16 z; - // +-X - if(i == 0 || i == 1) - { - x = (i==0) ? lighting_min_d : lighting_max_d; - if(i == 0) - z = lighting_min_d; - else - z = lighting_max_d; - } - // +-Z - else - { - z = (i==0) ? lighting_min_d : lighting_max_d; - if(i == 0) - x = lighting_min_d; - else - x = lighting_max_d; - } - - // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - - { - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - if(n->getLight(LIGHTBANK_DAY) != 0) - { - light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); - } - //NOTE: This is broken, at least the index has to - // be incremented - } - } - } -#endif - -#if 1 - /* - Go through the edges and apply sunlight to them, not caring - about neighbors - */ - - // Four edges - for(s16 i=0; i<4; i++) - // Edge length - for(s16 j=lighting_min_d; - j<=lighting_max_d; - j++) - { - s16 x; - s16 z; - // +-X - if(i == 0 || i == 1) - { - x = (i==0) ? lighting_min_d : lighting_max_d; - if(i == 0) - z = lighting_min_d; - else - z = lighting_max_d; - } - // +-Z - else - { - z = (i==0) ? lighting_min_d : lighting_max_d; - if(i == 0) - x = lighting_min_d; - else - x = lighting_max_d; - } - - // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - - // Loop from top to down - { - u8 light = LIGHT_SUN; - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - if(light_propagates_content(n->d) == false) - { - light = 0; - } - else if(light != LIGHT_SUN - || sunlight_propagates_content(n->d) == false) - { - if(light > 0) - light--; - } - - n->setLight(LIGHTBANK_DAY, light); - n->setLight(LIGHTBANK_NIGHT, 0); - - if(light != 0) - { - // Insert light source - light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); - } - - // Increment index by y - vmanip.m_area.add_y(em, i, -1); - } - } - } -#endif - - /*for(s16 x=0; x=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--; - } - - // This doesn't take much time - if(add_to_sources == false) - { - /* - Check sides. If side is not air or water, start - adding to light_sources. - */ - v3s16 dirs4[4] = { - v3s16(0,0,1), // back - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(-1,0,0), // left - }; - for(u32 di=0; di<4; di++) - { - v3s16 dirp = dirs4[di]; - u32 i2 = i; - vmanip.m_area.add_p(em, i2, dirp); - MapNode *n2 = &vmanip.m_data[i2]; - if( - n2->d != CONTENT_AIR - && n2->d != CONTENT_WATERSOURCE - && n2->d != CONTENT_WATER - ){ - add_to_sources = true; - break; - } - } - } - - n->setLight(LIGHTBANK_DAY, light); - n->setLight(LIGHTBANK_NIGHT, 0); - - // This doesn't take much time - if(light != 0 && add_to_sources) - { - // Insert light source - light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); - } - - // Increment index by y - vmanip.m_area.add_y(em, i, -1); - } - } - } -#endif - - }//timer1 - - // Spread light around - { - TimeTaker timer("generateChunkRaw() spreadLight"); - vmanip.spreadLight(LIGHTBANK_DAY, light_sources); - } - - /* - Generation ended - */ - - timer_generate.stop(); - - /* - Blit generated stuff to map - */ - { - // 70ms @cs=8 - //TimeTaker timer("generateChunkRaw() blitBackAll"); - vmanip.blitBackAll(&changed_blocks); - } - - /* - Update day/night difference cache of the MapBlocks - */ - { - for(core::map::Iterator i = changed_blocks.getIterator(); - i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - block->updateDayNightDiff(); - } - } - -#endif - - /* - Create chunk metadata - */ - - for(s16 x=-1; x<=1; x++) - for(s16 y=-1; y<=1; y++) - { - v2s16 chunkpos0 = chunkpos + v2s16(x,y); - // Add chunk meta information - MapChunk *chunk = getChunk(chunkpos0); - if(chunk == NULL) - { - chunk = new MapChunk(); - m_chunks.insert(chunkpos0, chunk); - } - //chunk->setIsVolatile(true); - if(chunk->getGenLevel() > GENERATED_PARTLY) - chunk->setGenLevel(GENERATED_PARTLY); - } - - /* - Set central chunk non-volatile - */ - MapChunk *chunk = getChunk(chunkpos); - assert(chunk); - // Set non-volatile - //chunk->setIsVolatile(false); - chunk->setGenLevel(GENERATED_FULLY); - - /* - Save changed parts of map - */ - save(true); - - /* - Return central chunk (which was requested) - */ - return chunk; -} -#endif - -#if 0 -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 " - <<"("<setLightingExpired(true); - // Lighting will be calculated - block->setLightingExpired(false); - - /* - Block gets sunlight if this is true. - - This should be set to true when the top side of a block - is completely exposed to the sky. - - Actually this doesn't matter now because the - initial lighting is done here. - */ - block->setIsUnderground(y != y_blocks_max); - } - } - } - - /* - Now we have a big empty area. - - Make a ManualMapVoxelManipulator that contains this and the - neighboring chunks - */ - - ManualMapVoxelManipulator vmanip(this); - // Add the area we just generated - { - TimeTaker timer("generateChunkRaw() initialEmerge"); - vmanip.initialEmerge(bigarea_blocks_min, bigarea_blocks_max); - } - - // Clear all flags - vmanip.clearFlag(0xff); - - TimeTaker timer_generate("generateChunkRaw() generate"); - - /* - Generate general ground level to full area - */ - - { - // 22ms @cs=8 - TimeTaker timer1("ground level"); - dstream<<"Generating base ground..."< 0.001); - - s16 surface_y = 0; - - float noturb_surface_y_f = base_rock_level_2d(m_seed, p2df); - s16 noturb_surface_y = noturb_surface_y_f; - - { - s16 depth_counter = 0; - s16 min = y_nodes_min; - s16 max = y_nodes_max; - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, max, p2d.Y)); - for(s16 y=max; y>=min; y--) - { - v3f p3df(p2df.X, y, p2df.Y); - - bool is_ground = false; - - bool turb_for_node = (turbulence_is_used - && y >= TURBULENCE_BOTTOM_CUTOFF_Y); - - if(is_carved(m_seed, p3df)) - { - is_ground = false; - } - else - { - if(turb_for_node) - { - double depth_guess; - is_ground = is_base_ground(m_seed, - p3df, &depth_guess); - - // Estimate the surface height - surface_y = y + depth_guess; - } - else - { - surface_y = noturb_surface_y; - } - - is_ground = (y <= surface_y); - } - - if(is_ground) - { - //vmanip.m_data[i].d = CONTENT_STONE; - /*if(y > surface_y - mud_amount) - vmanip.m_data[i].d = CONTENT_MUD; - else - vmanip.m_data[i].d = CONTENT_STONE;*/ - if(depth_counter < mud_amount) - vmanip.m_data[i].d = CONTENT_MUD; - else - vmanip.m_data[i].d = CONTENT_STONE; - } - else - vmanip.m_data[i].d = CONTENT_AIR; - - if(is_ground || depth_counter != 0) - depth_counter++; - -#if 0 -#if 1 - bool is = is_base_ground(m_seed, v3f(p2df.X,y,p2df.Y)); - if(is) - vmanip.m_data[i].d = CONTENT_STONE; - else - vmanip.m_data[i].d = CONTENT_AIR; -#endif -#endif - - vmanip.m_area.add_y(em, i, -1); - } - } - } - - }//timer1 - - { - // 50ms @cs=8 - //TimeTaker timer1("add water"); - - /* - Add water to the central chunk (and a bit more) - */ - - for(s16 x=0-max_spread_amount; - x WATER_LEVEL) - continue;*/ - - /* - Add water on ground - */ - { - v3s16 em = vmanip.m_area.getExtent(); - u8 light = LIGHT_MAX; - // Start at global water surface level - s16 y_start = WATER_LEVEL; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; - - /*// Add first one to transforming liquid queue, if water - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y_start, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ - - for(s16 y=y_start; y>=y_nodes_min; y--) - { - n = &vmanip.m_data[i]; - - // Stop when there is no water and no air - if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE - && n->d != CONTENT_WATER) - { - /*// Add bottom one to transforming liquid queue - vmanip.m_area.add_y(em, i, 1); - n = &vmanip.m_data[i]; - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ - - break; - } - - // Make water only not in dungeons - if(!(vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) - { - n->d = CONTENT_WATERSOURCE; - //n->setLight(LIGHTBANK_DAY, light); - - // Add to transforming liquid queue (in case it'd - // start flowing) - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - } - - // Next one - vmanip.m_area.add_y(em, i, -1); - if(light > 0) - light--; - } - } - - } - - }//timer1 - - { - //TimeTaker timer1("convert mud to sand"); - - /* - Convert mud to sand - */ - - //s16 mud_add_amount = myrand_range(2, 4); - //s16 mud_add_amount = 0; - - /*for(s16 x=0; x WATER_LEVEL + 2) - continue; - - { - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = surface_y; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - u32 not_sand_counter = 0; - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - { - n->d = CONTENT_SAND; - } - else - { - not_sand_counter++; - if(not_sand_counter > 3) - break; - } - - vmanip.m_area.add_y(em, i, -1); - } - } - - } - - }//timer1 - - { - // 19ms @cs=8 - //TimeTaker timer1("grow grass"); - - /* - Grow grass - */ - - /*for(s16 x=0-4; x=y_nodes_min; y--) - { - MapNode &n = vmanip.m_data[i]; - if(n.d != CONTENT_AIR - && n.d != CONTENT_LEAVES) - break; - vmanip.m_area.add_y(em, i, -1); - } - if(y >= y_nodes_min) - surface_y = y; - else - surface_y = y_nodes_min; - } - - u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); - MapNode *n = &vmanip.m_data[i]; - if(n->d == CONTENT_MUD) - n->d = CONTENT_GRASS; - } - - }//timer1 - - { - // 1ms @cs=8 - //TimeTaker timer1("generate trees"); - - /* - Generate some trees - */ - { - // Divide area into parts - s16 div = 8; - s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; - double area = sidelen * sidelen; - for(s16 x0=0; x0d != CONTENT_MUD && n->d != CONTENT_GRASS) - continue; - } - p.Y++; - // Make a tree - make_tree(vmanip, p); - } - } - /*u32 tree_max = relative_area / 60; - //u32 count = myrand_range(0, tree_max); - for(u32 i=0; i light_sources; - - { - // 750ms @cs=8, can't optimize more - TimeTaker timer1("initial lighting"); - -#if 1 - /* - This has to be 1 smaller than the actual area, because - neighboring nodes are checked. - */ - for(s16 x=lighting_min_d+1; - x<=lighting_max_d-1; - x++) - for(s16 z=lighting_min_d+1; - z<=lighting_max_d-1; - z++) - { - // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - - /* - Apply initial sunlight - */ - { - u8 light = LIGHT_SUN; - bool add_to_sources = false; - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - - if(light_propagates_content(n->d) == false) - { - light = 0; - } - else if(light != LIGHT_SUN - || sunlight_propagates_content(n->d) == false) - { - if(light > 0) - light--; - } - - // This doesn't take much time - if(add_to_sources == false) - { - /* - Check sides. If side is not air or water, start - adding to light_sources. - */ - v3s16 dirs4[4] = { - v3s16(0,0,1), // back - v3s16(1,0,0), // right - v3s16(0,0,-1), // front - v3s16(-1,0,0), // left - }; - for(u32 di=0; di<4; di++) - { - v3s16 dirp = dirs4[di]; - u32 i2 = i; - vmanip.m_area.add_p(em, i2, dirp); - MapNode *n2 = &vmanip.m_data[i2]; - if( - n2->d != CONTENT_AIR - && n2->d != CONTENT_WATERSOURCE - && n2->d != CONTENT_WATER - ){ - add_to_sources = true; - break; - } - } - } - - n->setLight(LIGHTBANK_DAY, light); - n->setLight(LIGHTBANK_NIGHT, 0); - - // This doesn't take much time - if(light != 0 && add_to_sources) - { - // Insert light source - light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); - } - - // Increment index by y - vmanip.m_area.add_y(em, i, -1); - } - } - } -#endif - - }//timer1 - - // Spread light around - { - TimeTaker timer("generateChunkRaw() spreadLight"); - vmanip.spreadLight(LIGHTBANK_DAY, light_sources); - } - - /* - Generation ended - */ - - timer_generate.stop(); - - /* - Blit generated stuff to map - */ - { - // 70ms @cs=8 - //TimeTaker timer("generateChunkRaw() blitBackAll"); - vmanip.blitBackAll(&changed_blocks); - } - - /* - Update day/night difference cache of the MapBlocks - */ - { - for(core::map::Iterator i = changed_blocks.getIterator(); - i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - block->updateDayNightDiff(); - } - } -#endif - - /* - Create chunk metadata - */ - - for(s16 x=-1; x<=1; x++) - for(s16 y=-1; y<=1; y++) - { - v2s16 chunkpos0 = chunkpos + v2s16(x,y); - // Add chunk meta information - MapChunk *chunk = getChunk(chunkpos0); - if(chunk == NULL) - { - chunk = new MapChunk(); - m_chunks.insert(chunkpos0, chunk); - } - //chunk->setIsVolatile(true); - if(chunk->getGenLevel() > GENERATED_PARTLY) - chunk->setGenLevel(GENERATED_PARTLY); - } - - /* - Set central chunk non-volatile - */ - MapChunk *chunk = getChunk(chunkpos); - assert(chunk); - // Set non-volatile - //chunk->setIsVolatile(false); - chunk->setGenLevel(GENERATED_FULLY); - - /* - Save changed parts of map - */ - save(true); - - /* - Return central chunk (which was requested) - */ - return chunk; -} - - -MapChunk* ServerMap::generateChunk(v2s16 chunkpos1, - core::map &changed_blocks) -{ - dstream<<"generateChunk(): Generating chunk " - <<"("<getGenLevel() == GENERATED_FULLY) - continue; - generateChunkRaw(chunkpos0, changed_blocks); - } - - assert(chunkNonVolatile(chunkpos1)); - - MapChunk *chunk = getChunk(chunkpos1); - return chunk; -} -#endif - -ServerMapSector * ServerMap::createSector(v2s16 p2d) -{ - DSTACK("%s: p2d=(%d,%d)", - __FUNCTION_NAME, - p2d.X, p2d.Y); - - /* - Check if it exists already in memory - */ - ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); - if(sector != NULL) - return sector; - - /* - Try to load it from disk (with blocks) - */ - if(loadSectorFull(p2d) == true) - { - ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); - if(sector == NULL) - { - dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"< MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE - || p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) - throw InvalidPositionException("createSector(): pos. over limit"); - - /* - Generate blank sector - */ - - sector = new ServerMapSector(this, p2d); - - // Sector position on map in nodes - v2s16 nodepos2d = p2d * MAP_BLOCKSIZE; - - /* - Insert to container - */ - m_sectors.insert(p2d, sector); - - return sector; -} - -MapSector * ServerMap::emergeSector(v2s16 p2d, - core::map &changed_blocks) -{ - DSTACK("%s: p2d=(%d,%d)", - __FUNCTION_NAME, - p2d.X, p2d.Y); - -#if 0 - /* - Check chunk status - */ - v2s16 chunkpos = sector_to_chunk(p2d); - /*bool chunk_nonvolatile = false; - MapChunk *chunk = getChunk(chunkpos); - if(chunk && chunk->getIsVolatile() == false) - chunk_nonvolatile = true;*/ - bool chunk_nonvolatile = chunkNonVolatile(chunkpos); - - /* - If chunk is not fully generated, generate chunk - */ - if(chunk_nonvolatile == false) - { - // Generate chunk and neighbors - generateChunk(chunkpos, changed_blocks); - } -#endif - - /* - Return sector if it exists now - */ - MapSector *sector = getSectorNoGenerateNoEx(p2d); - if(sector != NULL) - return sector; - - /* - Try to load it from disk - */ - if(loadSectorFull(p2d) == true) - { - MapSector *sector = getSectorNoGenerateNoEx(p2d); - if(sector == NULL) - { - dstream<<"ServerMap::emergeSector(): loadSectorFull didn't make a sector"<vmanip.m_area.index(p); + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_STONE) + n->param = mineral; + } + } + } + } -MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, - core::map &changed_blocks, - bool force) -{ - DSTACK(__FUNCTION_NAME); - - /* - Don't generate if already fully generated - */ - if(force == false) - { - MapBlock *block = getBlockNoCreateNoEx(blockpos0); - if(block != NULL && block->isFullyGenerated()) - { - dstream<<"generateBlockRaw(): Block " - <<"("< blocks_created; - + for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++) { - //TimeTaker timer("generateBlockRaw() create area"); + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - for(s16 x=-1; x<=1; x++) - for(s16 z=-1; z<=1; z++) + // Randomize mud amount + s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0; + + // Find ground level + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); + + /* + If topmost node is grass, change it to mud. + It might be if it was flown to there from a neighboring + chunk and then converted. + */ { - v2s16 sectorpos = sectorpos0 + v2s16(x,z); - ServerMapSector *sector = createSector(sectorpos); - assert(sector); + 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 = MapNode(CONTENT_MUD); + //n->d = CONTENT_MUD; + } - for(s16 y=blockpos0.Y-1; y<=blockpos0.Y+1; y++) + /* + Add mud on ground + */ + { + s16 mudcount = 0; + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = surface_y+1; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + for(s16 y=y_start; y<=y_nodes_max; y++) { - v3s16 blockpos(sectorpos.X, y, sectorpos.Y); - - MapBlock *block = getBlockNoCreateNoEx(blockpos); - if(block && block->isDummy() == false) - continue; + if(mudcount >= mud_add_amount) + break; - block = createBlock(blockpos); - block->setFullyGenerated(false); - - blocks_created.push_back(blockpos); - - // Lighting won't be calculated - block->setLightingExpired(true); - // Lighting will be calculated - //block->setLightingExpired(false); - - /* - Block gets sunlight if this is true. - - This should be set to true when the top side of a block - is completely exposed to the sky. + MapNode &n = data->vmanip.m_data[i]; + n = MapNode(CONTENT_MUD); + //n.d = CONTENT_MUD; + mudcount++; - This doesn't matter if the initial lighting is done - here. - */ - //block->setIsUnderground(y != y_blocks_max); - block->setIsUnderground(false); + data->vmanip.m_area.add_y(em, i, 1); } } - } - - /* - Now we have a big empty area of (16x16x16)x27. - Make a ManualMapVoxelManipulator that contains the whole area. - */ - - ManualMapVoxelManipulator vmanip(this); - // Add the area we just generated - { - //TimeTaker timer("generateBlockRaw() initialEmerge"); - vmanip.initialEmerge(blockpos0-v3s16(1,1,1), blockpos0+v3s16(1,1,1)); } - // Clear all flags - vmanip.clearFlag(0xff); + }//timer1 +#endif - // Block type of blockpos0 - BlockType center_block_type = BT_SURFACE; +#if 1 + { + // 340ms @cs=8 + TimeTaker timer1("flow mud"); /* - Generate general ground level to newly created blocks. - Only stone is used and it is converted to other stuff later on. + Flow mud away from steep edges */ + + // Limit area by 1 because mud is flown into neighbors. + 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++) { - // 22ms @cs=8 - //dstream<<"Generating base ground..."<::Iterator i = blocks_created.begin(); - i != blocks_created.end(); i++) - { - v3s16 blockpos = *i; - v2s16 sectorpos(blockpos.X, blockpos.Z); - /* - Approximate whether this block is a surface block, an air - block or a ground block. + for(s16 x=mudflow_minpos; + x<=mudflow_maxpos; + x++) + for(s16 z=mudflow_minpos; + z<=mudflow_maxpos; + z++) + { + // Invert coordinates every 2nd iteration + if(k%2 == 0) + { + x = mudflow_maxpos - (x-mudflow_minpos); + z = mudflow_maxpos - (z-mudflow_minpos); + } - This shall never mark a surface block as non-surface. - */ + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - BlockType block_type = BT_SURFACE; - v3s16 p_nodes = blockpos * MAP_BLOCKSIZE; - s32 lowest_ground_y = 32767; - s32 highest_ground_y = -32768; - u8 water_material = CONTENT_WATERSOURCE; + 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--) { - /* - Estimate surface at different positions of the block, to - try to accomodate the effect of turbulence. - */ - v3f checklist[] = { - v3f(0,0,0), - v3f(0,1,0), - v3f(0,1,1), - v3f(0,0,1), - v3f(1,0,0), - v3f(1,1,0), - v3f(1,1,1), - v3f(1,0,1), - v3f(0.5,0.5,0.5), - }; - v3f p_nodes_f = intToFloat(p_nodes, 1); - float surface_y_max = -1000000; - float surface_y_min = 1000000; - for(u32 i=0; i=y_nodes_min; y--) { - v3f p_map_f = p_nodes_f + checklist[i]*MAP_BLOCKSIZE; - - double depth_guess; - /*bool is_ground =*/ is_base_ground(m_seed, p_map_f, &depth_guess); - - // Estimate the surface height - float surface_y_f = p_map_f.Y + depth_guess; - - if(surface_y_f > surface_y_max) - surface_y_max = surface_y_f; - if(surface_y_f < surface_y_min) - surface_y_min = surface_y_f; + n = &data->vmanip.m_data[i]; + //if(content_walkable(n->d)) + // break; + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + break; + + data->vmanip.m_area.add_y(em, i, -1); } - float block_low_y_f = p_nodes_f.Y; - float block_high_y_f = p_nodes_f.Y + MAP_BLOCKSIZE; - - /*dstream<<"surface_y_max="<= surface_y_max + d_up - && block_low_y_f > WATER_LEVEL + d_up) - { - //dstream<<"BT_SKY"<vmanip.m_data[i]; + if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + continue;*/ - if(/*block_type == BT_GROUND ||*/ block_type == BT_SKY) + /* + Don't flow it if the stuff under it is not mud + */ { - lowest_ground_y = surface_y_min; - highest_ground_y = surface_y_max; + u32 i2 = i; + data->vmanip.m_area.add_y(em, i2, -1); + // Cancel if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + MapNode *n2 = &data->vmanip.m_data[i2]; + if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS) + continue; } - } - - if(blockpos == blockpos0) - center_block_type = block_type; - - if(block_type == BT_GROUND) - { - MapBlock *block = getBlockNoCreateNoEx(blockpos); - if(block) - block->setIsUnderground(true); - } - - /* - If the block has ground, generate ground precisely. - */ - - if(block_type == BT_SURFACE || block_type == BT_GROUND) - { - for(s16 z0=0; z0 0.001); - - float surface_y_f = 0; - s16 surface_y = 0; - - float noturb_surface_y_f = base_rock_level_2d(m_seed, real_p2d_f); - s16 noturb_surface_y = noturb_surface_y_f; - - // Get some statistics of surface height - if(noturb_surface_y < lowest_ground_y) - lowest_ground_y = noturb_surface_y; - if(noturb_surface_y > highest_ground_y) - highest_ground_y = noturb_surface_y; - - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16( - real_p2d.X, - blockpos.Y*MAP_BLOCKSIZE, - real_p2d.Y)); - for(s16 y0=0; y0= TURBULENCE_BOTTOM_CUTOFF_Y); - bool is_cavern = false; - - if(is_carved(m_seed, real_pos_f)) - { - is_ground = false; - if(real_y < noturb_surface_y) - is_cavern = true; - } - else - { - if(turb_for_node) - { - double depth_guess; - is_ground = is_base_ground(m_seed, - real_pos_f, &depth_guess); - - // Estimate the surface height - surface_y_f = (float)real_y + depth_guess; - surface_y = real_y + depth_guess; - - // Save some statistics of surface height - if(surface_y < lowest_ground_y) - lowest_ground_y = surface_y; - if(surface_y > highest_ground_y) - highest_ground_y = surface_y; - } - else - { - surface_y = noturb_surface_y; - } - - is_ground = (real_y <= surface_y); - } + // Make it exactly mud + n->d = CONTENT_MUD; + + /*s16 recurse_count = 0; + mudflow_recurse:*/ - // If node is not ground, it's air or water - if(is_ground == false) - { - // If under water level, it's water - if(real_y < WATER_LEVEL && !is_cavern) - { - n.d = water_material; - u8 dist = 16; - if(real_y >= surface_y) - dist = WATER_LEVEL-real_y+1; - n.setLight(LIGHTBANK_DAY, - diminish_light(LIGHT_SUN, dist)); - /* - Add to transforming liquid queue (in case it'd - start flowing) - */ - m_transforming_liquid.push_back(real_pos); - } - // else air - else - { - n.d = CONTENT_AIR; - - /* - Guess lighting - */ - if(real_y > surface_y + 4) - n.setLight(LIGHTBANK_DAY, LIGHT_SUN); - } - } - // Else it's ground - else - { - if(is_underground_mud(m_seed, real_pos_f)) - n.d = CONTENT_MUD; - else - n.d = CONTENT_STONE; - } + v3s16 dirs4[4] = { + v3s16(0,0,1), // back + v3s16(1,0,0), // right + v3s16(0,0,-1), // front + v3s16(-1,0,0), // left + }; - vmanip.m_data[i] = n; - vmanip.m_area.add_y(em, i, 1); - } - } - }// BT_SURFACE - else // BT_SKY or anything else - { - MapNode n_fill; - if(block_type == BT_GROUND) - { - //n_fill.d = CONTENT_STONE; - } - else if(block_type == BT_SKY) - { - n_fill.d = CONTENT_AIR; - n_fill.setLight(LIGHTBANK_DAY, LIGHT_SUN); - } - else // fallback + // Theck that upper is air or doesn't exist. + // Cancel dropping if upper keeps it in place + u32 i3 = i; + 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) { - n_fill.d = CONTENT_MESE; + continue; } - for(s16 x=0; xvmanip.m_area.add_p(em, i2, dirp); + // Fail if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + // Check that side is air + MapNode *n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + // Check that under side is air + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue; + /*// Check that under that is air (need a drop of 2) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + if(content_walkable(n2->d)) + continue;*/ + // Loop further down until not air + do{ + data->vmanip.m_area.add_y(em, i2, -1); + // Fail if out of area + if(data->vmanip.m_area.contains(i2) == false) + continue; + n2 = &data->vmanip.m_data[i2]; + }while(content_walkable(n2->d) == false); + // Loop one up so that we're in air + data->vmanip.m_area.add_y(em, i2, 1); + n2 = &data->vmanip.m_data[i2]; - { - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - s16 min = blockpos.Y*MAP_BLOCKSIZE; - s16 max = min + MAP_BLOCKSIZE-1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, min, p2d.Y)); - for(s16 y=min; y<=max; y++) - { - vmanip.m_data[i] = n_fill; - vmanip.m_area.add_y(em, i, 1); - } - } + // Move mud to new place + *n2 = *n; + // Set old place to be air + *n = MapNode(CONTENT_AIR); + + // Done + break; } } } + + } }//timer1 +#endif + +#if 1 + { + // 50ms @cs=8 + TimeTaker timer1("add water"); /* - Convert surface ground to mud + Add water to the central chunk (and a bit more) */ - if(center_block_type == BT_SURFACE) + for(s16 x=0-data->max_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + x++) + for(s16 z=0-data->max_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + z++) { -#if 1 - for(s16 x=0; xsectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + // Find ground level + //s16 surface_y = find_ground_level(data->vmanip, p2d); + + /* + If ground level is over water level, skip. + NOTE: This leaves caves near water without water, + which looks especially crappy when the nearby water + won't start flowing either for some reason + */ + /*if(surface_y > WATER_LEVEL) + continue;*/ + + /* + Add water on ground + */ { - // Node position - v2s16 p2d = sectorpos0*MAP_BLOCKSIZE + v2s16(x,z); - v2f real_p2d_f(p2d.X,p2d.Y); - + v3s16 em = data->vmanip.m_area.getExtent(); + u8 light = LIGHT_MAX; + // Start at global water surface level + s16 y_start = WATER_LEVEL; + 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--) { - // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - s16 min = blockpos0.Y*MAP_BLOCKSIZE; - // Start from one above the central block - s16 max = min + MAP_BLOCKSIZE-1+1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, max, p2d.Y)); - // If stone, there won't be mud - if(vmanip.m_data[i].d == CONTENT_STONE) - continue; - // Find top of ground - bool found = false; - s16 y; - for(y=max; y>=min; y--) + 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) { - if(vmanip.m_data[i].d == CONTENT_STONE) - { - found = true; - break; - } - vmanip.m_area.add_y(em, i, -1); + + break; } - if(found == false) - continue; - // Set mud - s16 mud_amount = get_mud_amount(m_seed, real_p2d_f); - for(s16 j=0; jvmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) { - if(vmanip.m_data[i].d != CONTENT_STONE) - { - break; - } - if(j==0 && y >= WATER_LEVEL) - vmanip.m_data[i].d = CONTENT_GRASS; - else - vmanip.m_data[i].d = CONTENT_MUD; - vmanip.m_area.add_y(em, i, -1); + 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); + data->transforming_liquid.push_back(p); } + + // Next one + data->vmanip.m_area.add_y(em, i, -1); + if(light > 0) + light--; } } -#endif + } + }//timer1 +#endif + + } // Aging loop + /*********************** + END OF AGING LOOP + ************************/ + +#if 1 + { + //TimeTaker timer1("convert mud to sand"); + /* Convert mud to sand */ - if(center_block_type == BT_SURFACE) + + //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-data->max_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + z++) { - for(s16 x=0; xsectorpos_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, + data->seed+59420, 3, 0.50); - // Find ground level - s16 surface_y = find_ground_level_clever(vmanip, p2d); - - if(surface_y >= WATER_LEVEL + 2) - continue; + bool have_sand = (sandnoise > -0.15); - { - v3s16 em = vmanip.m_area.getExtent(); - s16 y_start = surface_y; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - u32 not_sand_counter = 0; - for(s16 y=y_start; y>=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - { - n->d = CONTENT_SAND; - } - else - { - not_sand_counter++; - if(not_sand_counter > 3) - break; - } + if(have_sand == false) + continue; - vmanip.m_area.add_y(em, i, -1); - } - } - } - } + // Determine whether to have clay in the sand here + double claynoise = noise2d_perlin( + 0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500, + data->seed+4321, 6, 0.95); - /* - Add some minerals - */ + bool have_clay = have_sand && (claynoise > 1.25); - if(center_block_type == BT_SURFACE || center_block_type == BT_GROUND) - { - s16 underground_level = 1 - blockpos0.Y; + // Find ground level + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); + + if(surface_y > WATER_LEVEL + 2) + continue; - /* - Add meseblocks - */ - for(s16 i=0; ivmanip.m_area.getExtent(); + s16 y_start = surface_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--) { - v3s16 cp( - (myrand()%(MAP_BLOCKSIZE-2))+1, - (myrand()%(MAP_BLOCKSIZE-2))+1, - (myrand()%(MAP_BLOCKSIZE-2))+1 - ); - cp += blockpos0*MAP_BLOCKSIZE; - - MapNode n; - n.d = CONTENT_MESE; - - for(u16 i=0; i<27; i++) + MapNode *n = &data->vmanip.m_data[i]; + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) { - if(vmanip.getNode(cp+g_27dirs[i]).d == CONTENT_STONE) - if(myrand()%8 == 0) - vmanip.setNode(cp+g_27dirs[i], n); + if(have_clay && (surface_y == WATER_LEVEL)) + n->d = CONTENT_CLAY; + else + n->d = CONTENT_SAND; + } + else + { + not_sand_counter++; + if(not_sand_counter > 3) + break; } + + data->vmanip.m_area.add_y(em, i, -1); } } - /* - Add coal - */ - u16 coal_amount = 60; - u16 coal_rareness = 120 / coal_amount; - if(coal_rareness == 0) - coal_rareness = 1; - if(myrand()%coal_rareness == 0) - { - u16 a = myrand() % 16; - u16 amount = coal_amount * a*a*a / 1000; - for(s16 i=0; isectorpos_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( + 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( + 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(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 - 1) + 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); { - if(vmanip.getNode(cp+g_27dirs[i]).d == CONTENT_STONE) - if(myrand()%8 == 0) - vmanip.setNode(cp+g_27dirs[i], n); + 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 && n->d != CONTENT_SAND) + continue; + // Papyrus grows only on mud and in water + if(n->d == CONTENT_MUD && y == WATER_LEVEL - 1) + { + p.Y++; + make_papyrus(data->vmanip, p); + } + // Don't make a tree under water level + if(y < WATER_LEVEL) + continue; + // Trees grow only on mud and grass + if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) + { + p.Y++; + make_tree(data->vmanip, p); + } + // Cactii grow only on sand + else if(n->d == CONTENT_SAND) + { + p.Y++; + make_cactus(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(data->vmanip, p); + }*/ } - + + }//timer1 +#endif + +#if 1 + { + // 19ms @cs=8 + //TimeTaker timer1("grow grass"); /* - Generate some trees + Grow grass */ - if(center_block_type == BT_SURFACE) + + /*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-data->max_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; + z++) { - // Divide area into this amount of parts - s16 div = 1; - s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; - double area = sidelen * sidelen; - for(s16 x0=0; x0sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + /* + Find the lowest surface to which enough light ends up + to make grass grow. + + Basically just wait until not air and not leaves. + */ + s16 surface_y = 0; { - // Center position of part of division - v2s16 p2d_center( - sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0, - sectorpos_base.Y*MAP_BLOCKSIZE + sidelen/2 + sidelen*z0 - ); - // Minimum edge of part of division - v2s16 p2d_min( - sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0, - sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0 - ); - // Maximum edge of part of division - v2s16 p2d_max( - sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1, - sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1 - ); - // Amount of trees - u32 tree_count = area * tree_amount_2d(m_seed, p2d_center); - // Put trees in random places on part of division - for(u32 i=0; ivmanip.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--) { - s16 x = myrand_range(p2d_min.X, p2d_max.X); - s16 z = myrand_range(p2d_min.Y, p2d_max.Y); - s16 y = find_ground_level(vmanip, v2s16(x,z)); - // Don't make a tree under water level - if(y < WATER_LEVEL) - continue; - // Don't make a tree in other blocks - if(y < blockpos0.Y*MAP_BLOCKSIZE - || y >= (blockpos0.Y+1)*MAP_BLOCKSIZE) - continue; - v3s16 p(x,y,z); - /* - Trees grow only on mud and grass - */ - { - u32 i = vmanip.m_area.index(v3s16(p)); - MapNode *n = &vmanip.m_data[i]; - if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) - continue; - } - p.Y++; - // Make a tree - make_tree(vmanip, p); + MapNode &n = data->vmanip.m_data[i]; + if(n.d != CONTENT_AIR + && n.d != CONTENT_LEAVES) + break; + data->vmanip.m_area.add_y(em, i, -1); } + if(y >= y_nodes_min) + surface_y = y; + else + surface_y = y_nodes_min; } + + 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; } -#if 0 + }//timer1 +#endif + /* Initial lighting (sunlight) - TODO: Do the lighting this way, with the VoxelManipulator */ core::map light_sources; @@ -5626,7 +3360,63 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, { // 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 + */ + // Four edges + for(s16 i=0; i<4; i++) + // Edge length + for(s16 j=lighting_min_d; + j<=lighting_max_d; + j++) + { + s16 x; + s16 z; + // +-X + if(i == 0 || i == 1) + { + x = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + z = lighting_min_d; + else + z = lighting_max_d; + } + // +-Z + else + { + z = (i==0) ? lighting_min_d : lighting_max_d; + if(i == 0) + x = lighting_min_d; + else + x = lighting_max_d; + } + + // Node position in 2d + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + + { + v3s16 em = data->vmanip.m_area.getExtent(); + s16 y_start = y_nodes_max; + 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 = &data->vmanip.m_data[i]; + if(n->getLight(LIGHTBANK_DAY) != 0) + { + light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); + } + //NOTE: This is broken, at least the index has to + // be incremented + } + } + } +#endif + +#if 1 /* Go through the edges and apply sunlight to them, not caring about neighbors @@ -5661,17 +3451,17 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, } // 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; @@ -5693,11 +3483,21 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, } // 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-data->max_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; + z++)*/ +#if 1 /* This has to be 1 smaller than the actual area, because neighboring nodes are checked. @@ -5710,7 +3510,7 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, 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 @@ -5718,12 +3518,12 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, { 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) { @@ -5753,8 +3553,8 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, { 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 @@ -5777,122 +3577,466 @@ MapBlock* ServerMap::generateBlockRaw(v3s16 blockpos0, } // Increment index by y - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } +#endif }//timer1 // Spread light around { - TimeTaker timer("generateBlockRaw() spreadLight"); - vmanip.spreadLight(LIGHTBANK_DAY, light_sources); + TimeTaker timer("makeChunk() spreadLight"); + data->vmanip.spreadLight(LIGHTBANK_DAY, light_sources); + } + + /* + Generation ended + */ + + timer_generate.stop(); +} + +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### +//################################################################### + +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; + + // Check limits + const s16 limit = MAP_GENERATION_LIMIT / MAP_BLOCKSIZE; + if(sectorpos_bigbase.X < -limit + || sectorpos_bigbase.X + sectorpos_bigbase_size >= limit + || sectorpos_bigbase.Y < -limit + || sectorpos_bigbase.Y + sectorpos_bigbase_size >= limit) + { + data.no_op = true; + return; + } + + 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"); + data.vmanip.blitBackAll(&changed_blocks); + } + + /* + Update day/night difference cache of the MapBlocks + */ + { + for(core::map::Iterator i = changed_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + block->updateDayNightDiff(); + } + } + + /* + 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(true); + if(chunk->getGenLevel() > GENERATED_PARTLY) + chunk->setGenLevel(GENERATED_PARTLY); } -#endif /* - Blit generated stuff to map + Set central chunk non-volatile */ - { - vmanip.blitBackAll(&changed_blocks); - } + MapChunk *chunk = getChunk(data.chunkpos); + assert(chunk); + // Set non-volatile + //chunk->setIsVolatile(false); + chunk->setGenLevel(GENERATED_FULLY); + + /* + 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); + /* - Update day/night difference cache of the MapBlocks + Don't generate if already fully generated */ + if(force == false) { - for(core::map::Iterator i = changed_blocks.getIterator(); - i.atEnd() == false; i++) + MapChunk *chunk = getChunk(chunkpos); + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) { - MapBlock *block = i.getNode()->getValue(); - block->updateDayNightDiff(); + dstream<<"generateChunkRaw(): Chunk " + <<"("<::Iterator - i = changed_blocks*/ + dstream<<"generateChunkRaw(): Generating chunk " + <<"("<setFullyGenerated(true); + // Initialize generation + initChunkMake(data, chunkpos); + // Generate stuff + makeChunk(&data); + + // Finalize generation + MapChunk *chunk = finishChunkMake(data, changed_blocks); + /* - TODO: Calculate lighting with the VoxelManipulator, not this way + Return central chunk (which was requested) */ - // emergeBlock reads this - block->setLightingExpired(true); - // Also set the above one, trees often will be there + return chunk; +} + +// NOTE: Deprecated +MapChunk* ServerMap::generateChunk(v2s16 chunkpos1, + core::map &changed_blocks) +{ + dstream<<"generateChunk(): Generating chunk " + <<"("<setLightingExpired(true); + v2s16 chunkpos0 = chunkpos1 + v2s16(x,y); + MapChunk *chunk = getChunk(chunkpos0); + // Skip if already generated + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + continue; + generateChunkRaw(chunkpos0, changed_blocks); } + + assert(chunkNonVolatile(chunkpos1)); - return block; + MapChunk *chunk = getChunk(chunkpos1); + return chunk; } +#endif - -/*MapBlock* ServerMap::generateBlock(v3s16 blockpos1, - core::map &changed_blocks)*/ -MapBlock * ServerMap::generateBlock( - v3s16 blockpos1, - MapBlock *original_dummy, - ServerMapSector *sector, - core::map &changed_blocks, - core::map &lighting_invalidated_blocks -) +ServerMapSector * ServerMap::createSector(v2s16 p2d) { - dstream<<"generateBlock(): Generating block " - <<"("<isFullyGenerated()) - continue; - generateBlockRaw(blockpos0, changed_blocks); + ServerMapSector *sector = (ServerMapSector*)getSectorNoGenerateNoEx(p2d); + if(sector == NULL) + { + dstream<<"ServerMap::createSector(): loadSectorFull didn't make a sector"< MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p2d.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE + || p2d.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) + throw InvalidPositionException("createSector(): pos. over limit"); + + /* + Generate blank sector + */ - assert(blockNonVolatile(blockpos1)); + sector = new ServerMapSector(this, p2d); + + // Sector position on map in nodes + v2s16 nodepos2d = p2d * MAP_BLOCKSIZE; - MapBlock *block = getBlockNoCreate(blockpos1); + /* + Insert to container + */ + m_sectors.insert(p2d, sector); - return block; + return sector; } #if 0 +MapSector * ServerMap::emergeSector(v2s16 p2d, + core::map &changed_blocks) +{ + DSTACK("%s: p2d=(%d,%d)", + __FUNCTION_NAME, + p2d.X, p2d.Y); + + /* + Check chunk status + */ + v2s16 chunkpos = sector_to_chunk(p2d); + /*bool chunk_nonvolatile = false; + MapChunk *chunk = getChunk(chunkpos); + if(chunk && chunk->getIsVolatile() == false) + chunk_nonvolatile = true;*/ + bool chunk_nonvolatile = chunkNonVolatile(chunkpos); + + /* + If chunk is not fully generated, generate chunk + */ + if(chunk_nonvolatile == false) + { + // Generate chunk and neighbors + generateChunk(chunkpos, changed_blocks); + } + + /* + Return sector if it exists now + */ + MapSector *sector = getSectorNoGenerateNoEx(p2d); + if(sector != NULL) + return sector; + + /* + Try to load it from disk + */ + if(loadSectorFull(p2d) == true) + { + MapSector *sector = getSectorNoGenerateNoEx(p2d); + if(sector == NULL) + { + dstream<<"ServerMap::emergeSector(): loadSectorFull didn't make a 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."<removeBlock(block); // Allocate the block to contain the generated data - block->unDummify(); - } - - u8 water_material = CONTENT_WATERSOURCE; - - s32 lowest_ground_y = 32767; - s32 highest_ground_y = -32768; - - enum{ - BT_GROUND, - BT_SURFACE, - BT_SKY - } block_type = BT_SURFACE; - - {// ground_timer (0ms or ~100ms) - TimeTaker ground_timer("Ground generation"); - - /* - Approximate whether this block is a surface block, an air - block or a ground block. - - This shall never mark a surface block as non-surface. - */ - - { - /* - Estimate surface at different positions of the block, to - try to accomodate the effect of turbulence. - */ - v3f checklist[] = { - v3f(0,0,0), - v3f(0,1,0), - v3f(0,1,1), - v3f(0,0,1), - v3f(1,0,0), - v3f(1,1,0), - v3f(1,1,1), - v3f(1,0,1), - v3f(0.5,0.5,0.5), - }; - v3f p_nodes_f = intToFloat(p_nodes, 1); - float surface_y_max = -1000000; - float surface_y_min = 1000000; - for(u32 i=0; i surface_y_max) - surface_y_max = surface_y_f; - if(surface_y_f < surface_y_min) - surface_y_min = surface_y_f; - } - - float block_low_y_f = p_nodes_f.Y; - float block_high_y_f = p_nodes_f.Y + MAP_BLOCKSIZE; - - /*dstream<<"surface_y_max="<= surface_y_max + d_up - && block_low_y_f > WATER_LEVEL + d_up) - { - //dstream<<"BT_SKY"<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; - if(block_type == BT_SURFACE || block_type == BT_GROUND) + s32 lowest_ground_y = 32767; + s32 highest_ground_y = -32768; + + for(s16 z0=0; z0getNode(v3s16(x0,y0,z0)); - // Create dungeons + // Create caves if(underground_emptiness[ ued*ued*(z0*ued/MAP_BLOCKSIZE) +ued*(y0*ued/MAP_BLOCKSIZE) @@ -6602,7 +4500,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; } @@ -6611,7 +4509,6 @@ MapBlock * ServerMap::generateBlock( block->setNode(v3s16(x0,y0,z0), n); } } -#endif /* This is used for guessing whether or not the block should @@ -6623,7 +4520,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; @@ -6668,8 +4565,8 @@ MapBlock * ServerMap::generateBlock( /* Add coal */ - u16 coal_amount = 60; - u16 coal_rareness = 120 / coal_amount; + u16 coal_amount = 30; + u16 coal_rareness = 60 / coal_amount; if(coal_rareness == 0) coal_rareness = 1; if(myrand()%coal_rareness == 0) @@ -6700,8 +4597,9 @@ MapBlock * ServerMap::generateBlock( /* Add iron */ - u16 iron_amount = 40; - u16 iron_rareness = 80 / iron_amount; + //TODO: change to iron_amount or whatever + u16 iron_amount = 15; + u16 iron_rareness = 60 / iron_amount; if(iron_rareness == 0) iron_rareness = 1; if(myrand()%iron_rareness == 0) @@ -6752,57 +4650,16 @@ MapBlock * ServerMap::generateBlock( } } } + +#endif // end of proper block generation /* - Add block to sector + Add block to sector. */ sector->insertBlock(block); - // Lighting is invalid after generation for surface blocks - if(block_type == BT_SURFACE) - { -#if 1 - block->setLightingExpired(true); - lighting_invalidated_blocks.insert(p, block); -#else - block->setLightingExpired(false); -#endif - } - // Lighting is not invalid for other blocks - else - { - block->setLightingExpired(false); - } - - /* - Add trees - */ -#if 1 - if(some_part_underground && !completely_underground) - { - MapVoxelManipulator vm(this); - - double a = tree_amount_2d(m_seed, v2s16(p_nodes.X+8, p_nodes.Z+8)); - u16 tree_count = (u16)(a*MAP_BLOCKSIZE*MAP_BLOCKSIZE); - for(u16 i=0; isetLightingExpired(true); #if 0 /* @@ -6810,11 +4667,11 @@ MapBlock * ServerMap::generateBlock( */ dstream <<"lighting_invalidated_blocks.size()" - <<", has_dungeons" + <<", has_caves" <<", completely_ug" <<", some_part_ug" <<" "< &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); @@ -6955,7 +4811,6 @@ MapBlock * ServerMap::emergeBlock( bool does_not_exist = false; bool lighting_expired = false; - bool half_generated = false; MapBlock *block = sector->getBlockNoCreateNoEx(block_y); if(block == NULL) @@ -6970,10 +4825,6 @@ MapBlock * ServerMap::emergeBlock( { lighting_expired = true; } - else if(block->isFullyGenerated() == false) - { - half_generated = true; - } else { // Valid block @@ -6981,27 +4832,24 @@ MapBlock * ServerMap::emergeBlock( return block; } - if(half_generated == false) + /* + If block was not found on disk and not going to generate a + new one, make sure there is a dummy block in place. + */ + if(only_from_disk && (does_not_exist || lighting_expired)) { - /* - If block was not found on disk and not going to generate a - new one, make sure there is a dummy block in place. - */ - if(only_from_disk && (does_not_exist || lighting_expired)) - { - //dstream<<"emergeBlock(): Was not on disk but not generating"<insertBlock(block); - } - // Done. - return block; + // Add block to sector + sector->insertBlock(block); } + // Done. + return block; } //dstream<<"Not found on disk, generating."<getLightingExpired(); + lighting_invalidated_blocks); } if(lighting_expired) @@ -7030,7 +4876,6 @@ MapBlock * ServerMap::emergeBlock( Initially update sunlight */ - if(lighting_expired) { core::map light_sources; bool black_air_left = false; @@ -7087,13 +4932,16 @@ s16 ServerMap::findGroundLevel(v2s16 p2d) /* Plan B: Get from map generator perlin noise function */ - double level = base_rock_level_2d(m_seed, p2d); + // 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::createDir(std::string path) +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++) @@ -7210,19 +5090,21 @@ void ServerMap::save(bool only_changed) } } +#if 0 +// NOTE: Doing this is insane. Deprecated and probably broken. void ServerMap::loadAll() { DSTACK(__FUNCTION_NAME); dstream< list = fs::GetDirListing(m_savedir+"/sectors/"); dstream<serialize(os, version); } + + setChunksNonModified(); } void ServerMap::loadChunkMeta() @@ -7460,7 +5346,6 @@ void ServerMap::loadChunkMeta() m_chunks.insert(p, chunk); } } -#endif void ServerMap::saveSectorMeta(ServerMapSector *sector) { @@ -7469,10 +5354,8 @@ 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 + "/meta"; std::ofstream o(fullpath.c_str(), std::ios_base::binary); @@ -7484,20 +5367,41 @@ void ServerMap::saveSectorMeta(ServerMapSector *sector) 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 + "/meta"; + 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 metafile"); - - 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; @@ -7507,14 +5411,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) { @@ -7533,7 +5454,7 @@ bool ServerMap::loadSectorFull(v2s16 p2d) Load blocks */ std::vector list2 = fs::GetDirListing - (m_savedir+"/sectors/"+sectorsubdir); + (sectordir); std::vector::iterator i2; for(i2=list2.begin(); i2!=list2.end(); i2++) { @@ -7541,16 +5462,25 @@ 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 } } + + if(loadlayout != 2) + { + 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; @@ -7589,32 +5516,27 @@ void ServerMap::saveBlock(MapBlock *block) */ o.write((char*)&version, 1); + // Write basic data block->serialize(o, version); - - /* - Versions up from 9 have block objects. - */ - if(version >= 9) - { - block->serializeObjects(o, version); - } - // We just wrote it to the disk + // Write extra data stored on disk + block->serializeDiskExtra(o, version); + + // We just wrote it to the disk so clear modified flag 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"); - + v3s16 p3d = getBlockPos(sectordir, blockfile); v2s16 p2d(p3d.X, p3d.Z); @@ -7645,26 +5567,21 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto created_new = true; } - // deserialize block data + // Read basic data block->deSerialize(is, version); - - /* - Versions up from 9 have block objects. - */ - if(version >= 9) - { - block->updateObjects(is, version, NULL, 0); - } + // Read extra data stored on disk + block->deSerializeDiskExtra(is, version); + + // If it's a new block, insert it to the map if(created_new) sector->insertBlock(block); /* - Convert old formats to new and save + Save blocks loaded in old format in new format */ - // Save old format blocks in new format - if(version < SER_FMT_VER_HIGHEST) + if(version < SER_FMT_VER_HIGHEST || save_after_load) { saveBlock(block); } @@ -7679,6 +5596,8 @@ void ServerMap::loadBlock(std::string sectordir, std::string blockfile, MapSecto "(SerializationError). Ignoring. " "A new one will be generated." <::Node *n = m_sectors.find(p2d); @@ -7765,7 +5684,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); } } @@ -7799,7 +5718,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; @@ -7902,7 +5821,7 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) continue; } - // This is ugly + // This is ugly (spherical distance limit?) /*if(m_control.range_all == false && d - 0.5*BS*MAP_BLOCKSIZE > range) continue;*/ @@ -7910,6 +5829,9 @@ void ClientMap::renderMap(video::IVideoDriver* driver, s32 pass) #if 1 /* 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; @@ -7946,28 +5868,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 @@ -8149,10 +6055,13 @@ void ClientMap::expireMeshes(bool only_daynight_diffed) 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 @@ -8160,22 +6069,26 @@ void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio) 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. @@ -8210,6 +6123,7 @@ void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio) b->updateMesh(daynight_ratio); } } +#endif void ClientMap::PrintInfo(std::ostream &out) { @@ -8368,7 +6282,8 @@ void MapVoxelManipulator::blitBack } ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map): - MapVoxelManipulator(map) + MapVoxelManipulator(map), + m_create_area(false) { }