X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fmap.cpp;h=bf9f38c877598d4a39af4975d2cd33fc937b89a3;hb=cffd40c5d6c1427d2cce7cbcfe57669da73459c6;hp=d48003d4acb31a7a6b100407388d3ed11c5b35c9;hpb=9a22d02903549c09f059b12f0ec06ea12a19abbb;p=dragonfireclient.git diff --git a/src/map.cpp b/src/map.cpp index d48003d4a..bf9f38c87 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); } @@ -606,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; @@ -837,9 +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. */ void Map::addNodeAndUpdate(v3s16 p, MapNode n, core::map &modified_blocks) @@ -876,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); @@ -897,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 @@ -906,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 @@ -940,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--){ @@ -981,7 +1002,7 @@ void Map::addNodeAndUpdate(v3s16 p, MapNode n, break; } } - + for(s32 i=0; i<2; i++) { enum LightBank bank = banks[i]; @@ -1084,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. @@ -1320,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; @@ -1370,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(); @@ -1422,9 +1449,6 @@ void Map::transformLiquids(core::map & modified_blocks) while(m_transforming_liquid.size() != 0) { - try - { - /* Get a queued transforming liquid node */ @@ -1683,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) { + dstream<<__FUNCTION_NAME<>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(u64 seed, v2f p) -{ - double sandnoise = noise2d_perlin( - 0.5+(float)p.X/500, 0.5+(float)p.Y/500, - seed+59420, 3, 0.50); - return (sandnoise > -0.15); -} + // 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="<0, 0->1, 1->0 -double contour(double v) -{ - v = fabs(v); - if(v >= 1.0) - return 0.0; - return (1.0-v); + //dstream<<"a="<0, -r->1, 0->1, r->1, 1->0 -double contour_flat_top(double v, double r) +double get_mud_add_amount(u64 seed, v2s16 p) { - 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)); + 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)); } -double base_rock_level_2d(u64 seed, v2f p) +/* + Adds random objects to block, depending on the content of the block +*/ +void addRandomObjects(MapBlock *block) { - // 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; - }*/ - - /*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;*/ - -#if 0 + for(s16 z0=0; z0>32)+985251, 9, 0.55); - if(m3 > h) - h = m3; + bool last_node_walkable = false; + for(s16 y0=0; y0getNodeNoEx(p); + if(n.d == CONTENT_IGNORE) + continue; + if(content_features(n.d).liquid_type != LIQUID_NONE) + continue; + if(content_features(n.d).walkable) + { + last_node_walkable = true; + continue; + } + if(last_node_walkable) + { + // If block contains light information + if(content_features(n.d).param_type == CPT_LIGHT) + { + if(n.getLight(LIGHTBANK_DAY) <= 3) + { + if(myrand() % 300 == 0) + { + v3f pos_f = intToFloat(p+block->getPosRelative(), BS); + pos_f.Y -= BS*0.4; + ServerActiveObject *obj = new RatSAO(NULL, 0, pos_f); + std::string data = obj->getStaticData(); + StaticObject s_obj(obj->getType(), + obj->getBasePosition(), data); + // Add some + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + block->m_static_objects.insert(0, s_obj); + delete obj; + } + if(myrand() % 300 == 0) + { + v3f pos_f = intToFloat(p+block->getPosRelative(), BS); + pos_f.Y -= BS*0.4; + ServerActiveObject *obj = new Oerkki1SAO(NULL,0,pos_f); + std::string data = obj->getStaticData(); + StaticObject s_obj(obj->getType(), + obj->getBasePosition(), data); + // Add one + block->m_static_objects.insert(0, s_obj); + delete obj; + } + } + } + } + last_node_walkable = false; + } } -#endif + block->setChangedFlag(); +} -#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 +#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1 -#if 0 - { - // 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 +/* + This is the main map generation method +*/ -#if 0 - { - // 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 +void makeChunk(ChunkMakeData *data) +{ + if(data->no_op) + return; - /* - The sutff before this comment is usually not used. - The stuff after this comment is usually used. - */ + 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; -#if 1 - { - // Pretty neat looking mountains - double m4 = 100.0 - 400.0 * noise2d_perlin_abs( - 0.324+(float)p.X/2000., 0.423+(float)p.Y/2000., - (seed>>32)+65012102, 7, 0.6); - if(m4 > h) - h = m4; - } -#endif + // Clear all flags + data->vmanip.clearFlag(0xff); -#if 1 - // Some kind of hill chains or something - { - double a1 = 30 - 130. * noise2d_perlin_abs( - 0.5+(float)p.X/500., 0.5+(float)p.Y/500., - seed+850342, 6, 0.63); - double d = 15; - if(a1 > d) - a1 = d + sqrt(a1-d); - /*if(a1 > h) - h = a1;*/ - if(a1 > 0) - h += a1; - } -#endif + TimeTaker timer_generate("makeChunk() generate"); + + // 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 1 - double base = -2. + 30. * noise2d_perlin( - 0.5+(float)p.X/1000., 0.5+(float)p.Y/1000., - (seed>>32)+653876, 7, 0.6); -#else - double base = 0; -#endif - -#if 1 /* - Combined with turbulence, this thing here is able to make very - awesome terrain, albeit rarely. + Generate general ground level to full area */ - - 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) { - // 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="<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++) { - h += base; - } -#else - h += base; -#endif - - return h; -} + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + // Ground height at this point + float surface_y_f = 0.0; -double base_rock_level_2d(u64 seed, v2s16 p) -{ - return base_rock_level_2d(seed, v2f((float)p.X, (float)p.Y)); -} + // 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; -v2f base_ground_turbulence(u64 seed, v3f p) -{ -#if 1 - double f = 20; + /* + 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; -#if 1 - // Cut off at a minimum height - { - double d = 5; - double min = WATER_LEVEL; - if(p.Y < min) - return v2f(0,0); - else if(p.Y < min + d) - f *= ((p.Y-min)/d); - } -#endif + /*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; -#if 1 - double vv = 0.75 + 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/200, - 0.5+p.Y/200, - 0.5+p.Z/200, - seed+4045, 6, 0.7); - - double v2 = f * noise3d_perlin( - 0.5+p.X/200, - 0.5+p.Y/200, - 0.5+p.Z/200, - seed+9495, 6, 0.7); - return v2f(v1*vve, v2*vve); -#else - return v2f(0,0); -#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 + for(s16 x=0; xsectorpos_bigbase_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_bigbase_size*MAP_BLOCKSIZE; z++) + { + // Node position + v2s16 p2d = data->sectorpos_bigbase*MAP_BLOCKSIZE + v2s16(x,z); + + /* + 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; + }*/ - double f = 10.0; - double y_div = 1.5; - - 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; - - 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); -} - -/* - 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 - - bool is_ground = true; - -#if 1 - if(is_carved(seed, p)) - is_ground = false; -#endif - - if(depth_guess || is_ground == true) - { - v2f t = base_ground_turbulence(seed, p); - - double surface_y_f = base_rock_level_2d(seed, v2f(p.X+t.X, p.Z+t.Y)); - -#if 0 - if(depth_guess) - { - // 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; - } -#endif -#if 1 - if(depth_guess) - { - // 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 - -/* - This is the main map generation method -*/ - -MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, - core::map &changed_blocks, - bool force) -{ - DSTACK(__FUNCTION_NAME); - - // Shall be not used now - //assert(0); - -#if 0 - - /* - 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"); - - // 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); - } - } - -#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; + // Ground height at this point + float surface_y_f = 0.0; // Use perlin noise for ground height - surface_y_f = base_rock_level_2d(m_seed, p2d); + surface_y_f = base_rock_level_2d(data->seed, p2d); /*// Experimental stuff { - float a = highlands_level_2d(m_seed, p2d); + float a = highlands_level_2d(data->seed, p2d); if(a > surface_y_f) surface_y_f = a; }*/ @@ -2692,17 +2385,24 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { // Use fast index incrementing - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_min, p2d.Y)); for(s16 y=y_nodes_min; yvmanip.m_data[i].d != CONTENT_AIR) + break; - vmanip.m_area.add_y(em, i, 1); + data->vmanip.m_data[i].d = CONTENT_STONE; + + data->vmanip.m_area.add_y(em, i, 1); } } -#endif } +#endif }//timer1 @@ -2710,167 +2410,49 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Randomize some parameters */ - s32 stone_obstacle_count = 0; + //s32 stone_obstacle_count = 0; /*s32 stone_obstacle_count = - rangelim((1.0+noise2d(m_seed+897, - sectorpos_base.X, sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ + rangelim((1.0+noise2d(data->seed+897, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ - s16 stone_obstacle_max_height = 0; + //s16 stone_obstacle_max_height = 0; /*s16 stone_obstacle_max_height = - rangelim((1.0+noise2d(m_seed+5902, - sectorpos_base.X, sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ - - /* - Loop this part, it will make stuff look older and newer nicely - */ - u32 age_count = 2; - for(u32 i_age=0; i_age=y_nodes_min; y--) - { - MapNode *n = &vmanip.m_data[i]; - /*if(content_walkable(n.d) - && n.d != CONTENT_MUD - && n.d != CONTENT_GRASS) - break;*/ - if(n->d == CONTENT_STONE) - break; - - if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) - { - mud_amount++; - /* - Change to mud because otherwise we might - be throwing mud on grass at the next - step - */ - n->d = CONTENT_MUD; - } - - vmanip.m_area.add_y(em, i, -1); - } - if(y >= y_nodes_min) - surface_y = y; - else - surface_y = y_nodes_min; - } + rangelim((1.0+noise2d(data->seed+5902, + data->sectorpos_base.X, data->sectorpos_base.Y))/2.0 * 30, 0, 100000);*/ + /* + Loop this part, it will make stuff look older and newer nicely + */ + const u32 age_loops = 2; + for(u32 i_age=0; i_age stone_surface_max_y) - stone_surface_max_y = y; - - count++; - if(count >= ob_size.Y) - break; - - vmanip.m_area.add_y(em, i, 1); - } - // Add mud - count = 0; - for(; y<=y_nodes_max - min_head_space; y++) - { - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_MUD; - count++; - if(count >= mud_amount) - break; - - vmanip.m_area.add_y(em, i, 1); - } - } - - } - } - - }//timer1 +#if 1 { // 24ms @cs=8 - //TimeTaker timer1("dungeons"); + //TimeTaker timer1("caves"); /* - Make dungeons + Make caves */ - u32 dungeons_count = relative_volume / 600000; + u32 caves_count = relative_volume / 400000; u32 bruises_count = relative_volume * stone_surface_max_y / 40000000; if(stone_surface_max_y < WATER_LEVEL) bruises_count = 0; - /*u32 dungeons_count = 0; + /*u32 caves_count = 0; u32 bruises_count = 0;*/ - for(u32 jj=0; jj caves_count); if(bruise_surface) { @@ -2879,31 +2461,34 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, /*min_tunnel_diameter = MYMAX(0, stone_surface_max_y/6); max_tunnel_diameter = myrand_range(MYMAX(0, stone_surface_max_y/6), MYMAX(0, stone_surface_max_y/2));*/ - /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(m_seed+42, - sectorpos_base.X, sectorpos_base.Y)), 0, 15);*/ + /*s16 tunnel_rou = rangelim(25*(0.5+1.0*noise2d(data->seed+42, + data->sectorpos_base.X, data->sectorpos_base.Y)), 0, 15);*/ tunnel_routepoints = 5; } + else + { + } // Allowed route area size in nodes v3s16 ar( - sectorpos_base_size*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE, h_blocks*MAP_BLOCKSIZE, - sectorpos_base_size*MAP_BLOCKSIZE + data->sectorpos_base_size*MAP_BLOCKSIZE ); // Area starting point in nodes v3s16 of( - sectorpos_base.X*MAP_BLOCKSIZE, - y_blocks_min*MAP_BLOCKSIZE, - sectorpos_base.Y*MAP_BLOCKSIZE + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE ); // Allow a bit more //(this should be more than the maximum radius of the tunnel) //s16 insure = 5; // Didn't work with max_d = 20 s16 insure = 10; - s16 more = max_spread_amount - max_tunnel_diameter/2 - insure; + s16 more = data->max_spread_amount - max_tunnel_diameter/2 - insure; ar += v3s16(1,0,1) * more * 2; of -= v3s16(1,0,1) * more; @@ -2911,7 +2496,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Allow half a diameter + 7 over stone surface s16 route_y_max = -of.Y + stone_surface_max_y + max_tunnel_diameter/2 + 7; - /*// If dungeons, don't go through surface too often + /*// If caves, don't go through surface too often if(bruise_surface == false) route_y_max -= myrand_range(0, max_tunnel_diameter*2);*/ @@ -2936,16 +2521,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, s16 route_start_y_min = route_y_min; s16 route_start_y_max = route_y_max; - // Start every 2nd dungeon from surface + // Start every 2nd cave from surface bool coming_from_surface = (jj % 2 == 0 && bruise_surface == false); if(coming_from_surface) { - route_start_y_min = -of.Y + stone_surface_max_y + 5; + route_start_y_min = -of.Y + stone_surface_max_y + 10; } route_start_y_min = rangelim(route_start_y_min, 0, ar.Y-1); - route_start_y_max = rangelim(route_start_y_max, 0, ar.Y-1); + route_start_y_max = rangelim(route_start_y_max, route_start_y_min, ar.Y-1); // Randomize starting position v3f orp( @@ -2962,6 +2547,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, for(u16 j=0; jvmanip.m_area.contains(p)); + if(data->vmanip.m_area.contains(p) == false) { dstream<<"WARNING: "<<__FUNCTION_NAME <<":"<<__LINE__<<": " @@ -3053,13 +2650,13 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Just set it to air, it will be changed to // water afterwards - u32 i = vmanip.m_area.index(p); - vmanip.m_data[i] = airnode; + u32 i = data->vmanip.m_area.index(p); + data->vmanip.m_data[i] = airnode; if(bruise_surface == false) { // Set tunnel flag - vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; + data->vmanip.m_flags[i] |= VMANIP_FLAG_DUNGEON; } } } @@ -3072,6 +2669,9 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 46ms @cs=8 //TimeTaker timer1("ore veins"); @@ -3085,22 +2685,22 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Allowed route area size in nodes v3s16 ar( - sectorpos_base_size*MAP_BLOCKSIZE, + data->sectorpos_base_size*MAP_BLOCKSIZE, h_blocks*MAP_BLOCKSIZE, - sectorpos_base_size*MAP_BLOCKSIZE + data->sectorpos_base_size*MAP_BLOCKSIZE ); // Area starting point in nodes v3s16 of( - sectorpos_base.X*MAP_BLOCKSIZE, - y_blocks_min*MAP_BLOCKSIZE, - sectorpos_base.Y*MAP_BLOCKSIZE + data->sectorpos_base.X*MAP_BLOCKSIZE, + data->y_blocks_min*MAP_BLOCKSIZE, + data->sectorpos_base.Y*MAP_BLOCKSIZE ); // Allow a bit more //(this should be more than the maximum radius of the tunnel) s16 insure = 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; @@ -3186,12 +2786,12 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, continue; p += of; - assert(vmanip.m_area.contains(p)); + assert(data->vmanip.m_area.contains(p)); // Just set it to air, it will be changed to // water afterwards - u32 i = vmanip.m_area.index(p); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(p); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_STONE) n->param = mineral; } @@ -3205,25 +2805,28 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 15ms @cs=8 - //TimeTaker timer1("add mud"); + TimeTaker timer1("add mud"); /* Add mud to the central chunk */ - for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Randomize mud amount - s16 mud_add_amount = get_mud_amount(m_seed, v2f(p2d.X,p2d.Y))/age_count; + s16 mud_add_amount = get_mud_add_amount(data->seed, p2d) / 2.0; // Find ground level - s16 surface_y = find_ground_level_clever(vmanip, p2d); + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); /* If topmost node is grass, change it to mud. @@ -3231,10 +2834,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, chunk and then converted. */ { - u32 i = vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, surface_y, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_GRASS) - n->d = CONTENT_MUD; + *n = MapNode(CONTENT_MUD); + //n->d = CONTENT_MUD; } /* @@ -3242,36 +2846,40 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { s16 mudcount = 0; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = surface_y+1; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); for(s16 y=y_start; y<=y_nodes_max; y++) { if(mudcount >= mud_add_amount) break; - MapNode &n = vmanip.m_data[i]; - n.d = CONTENT_MUD; + MapNode &n = data->vmanip.m_data[i]; + n = MapNode(CONTENT_MUD); + //n.d = CONTENT_MUD; mudcount++; - vmanip.m_area.add_y(em, i, 1); + data->vmanip.m_area.add_y(em, i, 1); } } } }//timer1 +#endif + +#if 1 { // 340ms @cs=8 - //TimeTaker timer1("flow mud"); + 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; + 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++) @@ -3292,10 +2900,10 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); s16 y=y_nodes_max; for(;; y--) @@ -3304,22 +2912,22 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Find mud for(; y>=y_nodes_min; y--) { - n = &vmanip.m_data[i]; + n = &data->vmanip.m_data[i]; //if(content_walkable(n->d)) // break; if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) break; - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } // Stop if out of area - //if(vmanip.m_area.contains(i) == false) + //if(data->vmanip.m_area.contains(i) == false) if(y < y_nodes_min) break; /*// If not mud, do nothing to it - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) continue;*/ @@ -3328,11 +2936,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ { u32 i2 = i; - vmanip.m_area.add_y(em, i2, -1); + data->vmanip.m_area.add_y(em, i2, -1); // Cancel if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; - MapNode *n2 = &vmanip.m_data[i2]; + MapNode *n2 = &data->vmanip.m_data[i2]; if(n2->d != CONTENT_MUD && n2->d != CONTENT_GRASS) continue; } @@ -3353,9 +2961,9 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Theck that upper is air or doesn't exist. // Cancel dropping if upper keeps it in place u32 i3 = i; - vmanip.m_area.add_y(em, i3, 1); - if(vmanip.m_area.contains(i3) == true - && content_walkable(vmanip.m_data[i3].d) == true) + data->vmanip.m_area.add_y(em, i3, 1); + if(data->vmanip.m_area.contains(i3) == true + && content_walkable(data->vmanip.m_data[i3].d) == true) { continue; } @@ -3367,39 +2975,39 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, v3s16 dirp = dirs4[di]; u32 i2 = i; // Move to side - vmanip.m_area.add_p(em, i2, dirp); + data->vmanip.m_area.add_p(em, i2, dirp); // Fail if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; // Check that side is air - MapNode *n2 = &vmanip.m_data[i2]; + MapNode *n2 = &data->vmanip.m_data[i2]; if(content_walkable(n2->d)) continue; // Check that under side is air - vmanip.m_area.add_y(em, i2, -1); - if(vmanip.m_area.contains(i2) == false) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->vmanip.m_data[i2]; if(content_walkable(n2->d)) continue; /*// Check that under that is air (need a drop of 2) - vmanip.m_area.add_y(em, i2, -1); - if(vmanip.m_area.contains(i2) == false) + data->vmanip.m_area.add_y(em, i2, -1); + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->vmanip.m_data[i2]; if(content_walkable(n2->d)) continue;*/ // Loop further down until not air do{ - vmanip.m_area.add_y(em, i2, -1); + data->vmanip.m_area.add_y(em, i2, -1); // Fail if out of area - if(vmanip.m_area.contains(i2) == false) + if(data->vmanip.m_area.contains(i2) == false) continue; - n2 = &vmanip.m_data[i2]; + n2 = &data->vmanip.m_data[i2]; }while(content_walkable(n2->d) == false); // Loop one up so that we're in air - vmanip.m_area.add_y(em, i2, 1); - n2 = &vmanip.m_data[i2]; + data->vmanip.m_area.add_y(em, i2, 1); + n2 = &data->vmanip.m_data[i2]; // Move mud to new place *n2 = *n; @@ -3415,26 +3023,29 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif + +#if 1 { // 50ms @cs=8 - //TimeTaker timer1("add water"); + TimeTaker timer1("add water"); /* Add water to the central chunk (and a bit more) */ - for(s16 x=0-max_spread_amount; - xmax_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; x++) - for(s16 z=0-max_spread_amount; - zmax_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Find ground level - //s16 surface_y = find_ground_level(vmanip, p2d); + //s16 surface_y = find_ground_level(data->vmanip, p2d); /* If ground level is over water level, skip. @@ -3449,42 +3060,27 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Add water on ground */ { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); u8 light = LIGHT_MAX; // Start at global water surface level s16 y_start = WATER_LEVEL; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); - MapNode *n = &vmanip.m_data[i]; - - /*// Add first one to transforming liquid queue, if water - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y_start, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + MapNode *n = &data->vmanip.m_data[i]; for(s16 y=y_start; y>=y_nodes_min; y--) { - n = &vmanip.m_data[i]; + n = &data->vmanip.m_data[i]; // Stop when there is no water and no air if(n->d != CONTENT_AIR && n->d != CONTENT_WATERSOURCE && n->d != CONTENT_WATER) { - /*// Add bottom one to transforming liquid queue - vmanip.m_area.add_y(em, i, 1); - n = &vmanip.m_data[i]; - if(n->d == CONTENT_WATER || n->d == CONTENT_WATERSOURCE) - { - v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); - }*/ break; } - // Make water only not in dungeons - if(!(vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) + // Make water only not in caves + if(!(data->vmanip.m_flags[i]&VMANIP_FLAG_DUNGEON)) { n->d = CONTENT_WATERSOURCE; //n->setLight(LIGHTBANK_DAY, light); @@ -3492,11 +3088,11 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Add to transforming liquid queue (in case it'd // start flowing) v3s16 p = v3s16(p2d.X, y, p2d.Y); - m_transforming_liquid.push_back(p); + data->transforming_liquid.push_back(p); } // Next one - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); if(light > 0) light--; } @@ -3505,9 +3101,14 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } }//timer1 +#endif } // Aging loop + /*********************** + END OF AGING LOOP + ************************/ +#if 1 { //TimeTaker timer1("convert mud to sand"); @@ -3518,41 +3119,55 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, //s16 mud_add_amount = myrand_range(2, 4); //s16 mud_add_amount = 0; - /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; x++) - for(s16 z=0-max_spread_amount+1; - zmax_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Determine whether to have sand here - bool have_sand = get_have_sand(p2d); + double sandnoise = noise2d_perlin( + 0.5+(float)p2d.X/500, 0.5+(float)p2d.Y/500, + data->seed+59420, 3, 0.50); + + bool have_sand = (sandnoise > -0.15); if(have_sand == false) continue; + // 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, 8, 0.95); + + bool have_clay = have_sand && (claynoise > 0.95); + // Find ground level - s16 surface_y = find_ground_level_clever(vmanip, p2d); + s16 surface_y = find_ground_level_clever(data->vmanip, p2d); if(surface_y > WATER_LEVEL + 2) continue; { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = surface_y; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); u32 not_sand_counter = 0; for(s16 y=y_start; y>=y_nodes_min; y--) { - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_MUD || n->d == CONTENT_GRASS) { - n->d = CONTENT_SAND; + if(have_clay && (surface_y == WATER_LEVEL)) + n->d = CONTENT_CLAY; + else + n->d = CONTENT_SAND; } else { @@ -3561,13 +3176,16 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, break; } - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } }//timer1 +#endif + +#if 1 { // 1ms @cs=8 //TimeTaker timer1("generate trees"); @@ -3578,72 +3196,83 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { // Divide area into parts s16 div = 8; - s16 sidelen = sectorpos_base_size*MAP_BLOCKSIZE / div; + s16 sidelen = data->sectorpos_base_size*MAP_BLOCKSIZE / div; double area = sidelen * sidelen; for(s16 x0=0; x0sectorpos_base.X*MAP_BLOCKSIZE + sidelen/2 + sidelen*x0, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen/2 + sidelen*z0 ); // Minimum edge of part of division v2s16 p2d_min( - sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0, - sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0 + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen*x0, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen*z0 ); // Maximum edge of part of division v2s16 p2d_max( - sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1, - sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1 + data->sectorpos_base.X*MAP_BLOCKSIZE + sidelen + sidelen*x0 - 1, + data->sectorpos_base.Y*MAP_BLOCKSIZE + sidelen + sidelen*z0 - 1 ); // Amount of trees - u32 tree_count = area * tree_amount_2d(m_seed, p2d_center); + u32 tree_count = area * tree_amount_2d(data->seed, p2d_center); // Put trees in random places on part of division for(u32 i=0; ivmanip, v2s16(x,z)); // Don't make a tree under water level if(y < WATER_LEVEL) continue; + // Don't make a tree so high that it doesn't fit + if(y > y_nodes_max - 6) + continue; v3s16 p(x,y,z); - /* - Trees grow only on mud and grass - */ { - u32 i = vmanip.m_area.index(v3s16(p)); - MapNode *n = &vmanip.m_data[i]; - if(n->d != CONTENT_MUD && n->d != CONTENT_GRASS) + 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; + // 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 + if(n->d == CONTENT_SAND) + { + p.Y++; + make_cactus(data->vmanip, p); + } } - 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; isectorpos_base_size*MAP_BLOCKSIZE-1); + s16 z = myrand_range(0, data->sectorpos_base_size*MAP_BLOCKSIZE-1); + x += data->sectorpos_base.X*MAP_BLOCKSIZE; + z += data->sectorpos_base.Y*MAP_BLOCKSIZE; + s16 y = find_ground_level(data->vmanip, v2s16(x,z)); // Don't make a tree under water level if(y < WATER_LEVEL) continue; v3s16 p(x,y+1,z); // Make a tree - make_tree(vmanip, p); + make_tree(data->vmanip, p); }*/ } }//timer1 +#endif +#if 1 { // 19ms @cs=8 //TimeTaker timer1("grow grass"); @@ -3652,17 +3281,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Grow grass */ - /*for(s16 x=0-4; xsectorpos_base_size*MAP_BLOCKSIZE+4; x++) + for(s16 z=0-4; zsectorpos_base_size*MAP_BLOCKSIZE+4; z++)*/ + for(s16 x=0-data->max_spread_amount; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; x++) - for(s16 z=0-max_spread_amount; - zmax_spread_amount; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount; z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); /* Find the lowest surface to which enough light ends up @@ -3672,17 +3301,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ s16 surface_y = 0; { - v3s16 em = vmanip.m_area.getExtent(); - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); + v3s16 em = data->vmanip.m_area.getExtent(); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_nodes_max, p2d.Y)); s16 y; // Go to ground level for(y=y_nodes_max; y>=y_nodes_min; y--) { - MapNode &n = vmanip.m_data[i]; + MapNode &n = data->vmanip.m_data[i]; if(n.d != CONTENT_AIR && n.d != CONTENT_LEAVES) break; - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } if(y >= y_nodes_min) surface_y = y; @@ -3690,13 +3319,14 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, surface_y = y_nodes_min; } - u32 i = vmanip.m_area.index(p2d.X, surface_y, p2d.Y); - MapNode *n = &vmanip.m_data[i]; + u32 i = data->vmanip.m_area.index(p2d.X, surface_y, p2d.Y); + MapNode *n = &data->vmanip.m_data[i]; if(n->d == CONTENT_MUD) n->d = CONTENT_GRASS; } }//timer1 +#endif /* Initial lighting (sunlight) @@ -3708,6 +3338,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // 750ms @cs=8, can't optimize more TimeTaker timer1("initial lighting"); + // NOTE: This is no used... umm... for some reason! #if 0 /* Go through the edges and add all nodes that have light to light_sources @@ -3742,15 +3373,15 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); { - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); for(s16 y=y_start; y>=y_nodes_min; y--) { - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(n->getLight(LIGHTBANK_DAY) != 0) { light_sources.insert(v3s16(p2d.X, y, p2d.Y), true); @@ -3797,17 +3428,17 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); // Loop from top to down { u8 light = LIGHT_SUN; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); for(s16 y=y_start; y>=y_nodes_min; y--) { - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(light_propagates_content(n->d) == false) { light = 0; @@ -3829,19 +3460,19 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Increment index by y - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } #endif - /*for(s16 x=0; xsectorpos_base_size*MAP_BLOCKSIZE; x++) + for(s16 z=0; zsectorpos_base_size*MAP_BLOCKSIZE; z++)*/ + /*for(s16 x=0-data->max_spread_amount+1; + xsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; x++) - for(s16 z=0-max_spread_amount+1; - zmax_spread_amount+1; + zsectorpos_base_size*MAP_BLOCKSIZE+data->max_spread_amount-1; z++)*/ #if 1 /* @@ -3856,7 +3487,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, z++) { // Node position in 2d - v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); + v2s16 p2d = data->sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z); /* Apply initial sunlight @@ -3864,12 +3495,12 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { u8 light = LIGHT_SUN; bool add_to_sources = false; - v3s16 em = vmanip.m_area.getExtent(); + v3s16 em = data->vmanip.m_area.getExtent(); s16 y_start = y_nodes_max; - u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); + u32 i = data->vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y)); for(s16 y=y_start; y>=y_nodes_min; y--) { - MapNode *n = &vmanip.m_data[i]; + MapNode *n = &data->vmanip.m_data[i]; if(light_propagates_content(n->d) == false) { @@ -3899,8 +3530,8 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, { v3s16 dirp = dirs4[di]; u32 i2 = i; - vmanip.m_area.add_p(em, i2, dirp); - MapNode *n2 = &vmanip.m_data[i2]; + data->vmanip.m_area.add_p(em, i2, dirp); + MapNode *n2 = &data->vmanip.m_data[i2]; if( n2->d != CONTENT_AIR && n2->d != CONTENT_WATERSOURCE @@ -3923,7 +3554,7 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } // Increment index by y - vmanip.m_area.add_y(em, i, -1); + data->vmanip.m_area.add_y(em, i, -1); } } } @@ -3933,8 +3564,8 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, // Spread light around { - TimeTaker timer("generateChunkRaw() spreadLight"); - vmanip.spreadLight(LIGHTBANK_DAY, light_sources); + TimeTaker timer("makeChunk() spreadLight"); + data->vmanip.spreadLight(LIGHTBANK_DAY, light_sources); } /* @@ -3942,14 +3573,148 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, */ 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"); - vmanip.blitBackAll(&changed_blocks); + data.vmanip.blitBackAll(&changed_blocks); } /* @@ -3964,8 +3729,35 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, } } -#endif - + /* + Copy transforming liquid information + */ + while(data.transforming_liquid.size() > 0) + { + v3s16 p = data.transforming_liquid.pop_front(); + m_transforming_liquid.push_back(p); + } + + /* + Add random objects to blocks + */ + { + for(s16 x=0; xsetIsVolatile(false); @@ -3999,6 +3791,49 @@ MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, Save changed parts of map */ save(true); + + return chunk; +} + +#if 0 +// NOTE: Deprecated +MapChunk* ServerMap::generateChunkRaw(v2s16 chunkpos, + core::map &changed_blocks, + bool force) +{ + DSTACK(__FUNCTION_NAME); + + /* + Don't generate if already fully generated + */ + if(force == false) + { + MapChunk *chunk = getChunk(chunkpos); + if(chunk != NULL && chunk->getGenLevel() == GENERATED_FULLY) + { + dstream<<"generateChunkRaw(): Chunk " + <<"("< &changed_blocks) { @@ -4013,9 +3849,6 @@ MapChunk* ServerMap::generateChunk(v2s16 chunkpos1, <<"("< &changed_blocks) { @@ -4144,6 +3979,13 @@ MapSector * ServerMap::emergeSector(v2s16 p2d, < &lighting_invalidated_blocks ) { - DSTACK("%s: p=(%d,%d,%d)", + DSTACKF("%s: p=(%d,%d,%d)", __FUNCTION_NAME, p.X, p.Y, p.Z); + + // If chunks are disabled + /*if(m_chunksize == 0) + { + dstream<<"ServerMap::generateBlock(): Chunks disabled -> " + <<"not generating."<unDummify(); } - 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"); - +#if 0 /* - 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. + Generate a completely empty block */ - - { - /* - 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"<setNode(v3s16(x0,y0,z0), n); } } +#else + /* + Generate a proper block + */ + + u8 water_material = CONTENT_WATERSOURCE; + + s32 lowest_ground_y = 32767; + s32 highest_ground_y = -32768; - if(block_type == BT_SURFACE || block_type == BT_GROUND) + 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) @@ -4841,7 +4477,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; } @@ -4850,7 +4486,6 @@ MapBlock * ServerMap::generateBlock( block->setNode(v3s16(x0,y0,z0), n); } } -#endif /* This is used for guessing whether or not the block should @@ -4862,7 +4497,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; @@ -4907,8 +4542,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) @@ -4939,8 +4574,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) @@ -4991,57 +4627,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 /* @@ -5049,11 +4644,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); @@ -5246,9 +4841,7 @@ MapBlock * ServerMap::emergeBlock( if(does_not_exist) { block = generateBlock(p, block, sector, changed_blocks, - lighting_invalidated_blocks); - - lighting_expired = block->getLightingExpired(); + lighting_invalidated_blocks); } if(lighting_expired) @@ -5260,7 +4853,6 @@ MapBlock * ServerMap::emergeBlock( Initially update sunlight */ - if(lighting_expired) { core::map light_sources; bool black_air_left = false; @@ -5317,13 +4909,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++) @@ -5440,6 +5067,8 @@ void ServerMap::save(bool only_changed) } } +#if 0 +// NOTE: Doing this is insane. Deprecated and probably broken. void ServerMap::loadAll() { DSTACK(__FUNCTION_NAME); @@ -5452,7 +5081,7 @@ void ServerMap::loadAll() dstream<serialize(os, version); } + + setChunksNonModified(); } void ServerMap::loadChunkMeta() @@ -5695,10 +5331,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); @@ -5710,20 +5344,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; @@ -5733,14 +5388,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) { @@ -5759,7 +5431,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++) { @@ -5767,16 +5439,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; @@ -5815,32 +5493,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); @@ -5871,26 +5544,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); } @@ -5905,6 +5573,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); @@ -5991,7 +5661,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); } } @@ -6025,7 +5695,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; @@ -6128,7 +5798,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;*/ @@ -6136,6 +5806,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; @@ -6172,28 +5845,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 @@ -6381,6 +6038,7 @@ void ClientMap::updateMeshes(v3s16 blockpos, u32 daynight_ratio) v3s16 p = blockpos + v3s16(0,0,0); MapBlock *b = getBlockNoCreate(p); b->updateMesh(daynight_ratio); + //b->setMeshExpired(true); } catch(InvalidPositionException &e){} // Leading edge @@ -6388,40 +6046,61 @@ 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){} - /*// Trailing edge - try{ - v3s16 p = blockpos + v3s16(1,0,0); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,1,0); - MapBlock *b = getBlockNoCreate(p); - b->updateMesh(daynight_ratio); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,0,1); - MapBlock *b = getBlockNoCreate(p); +} + +#if 0 +/* + Update mesh of block in which the node is, and if the node is at the + leading edge, update the appropriate leading blocks too. +*/ +void ClientMap::updateNodeMeshes(v3s16 nodepos, u32 daynight_ratio) +{ + v3s16 dirs[4] = { + v3s16(0,0,0), + v3s16(-1,0,0), + v3s16(0,-1,0), + v3s16(0,0,-1), + }; + v3s16 blockposes[4]; + for(u32 i=0; i<4; i++) + { + v3s16 np = nodepos + dirs[i]; + blockposes[i] = getNodeBlockPos(np); + // Don't update mesh of block if it has been done already + bool already_updated = false; + for(u32 j=0; jupdateMesh(daynight_ratio); } - catch(InvalidPositionException &e){}*/ } +#endif void ClientMap::PrintInfo(std::ostream &out) { @@ -6580,7 +6259,8 @@ void MapVoxelManipulator::blitBack } ManualMapVoxelManipulator::ManualMapVoxelManipulator(Map *map): - MapVoxelManipulator(map) + MapVoxelManipulator(map), + m_create_area(false) { }