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--){
break;
}
}
-
+
for(s32 i=0; i<2; i++)
{
enum LightBank bank = banks[i];
light_sources, modified_blocks);
}
+ /*
+ Remove node metadata
+ */
+
+ removeNodeMetadata(p);
+
/*
Remove the node.
This also clears the lighting.
while(m_transforming_liquid.size() != 0)
{
- try
- {
-
/*
Get a queued transforming liquid node
*/
}
loopcount++;
- if(loopcount >= initial_size * 1 || loopcount >= 1000)
+ //if(loopcount >= 100000)
+ if(loopcount >= initial_size * 1)
break;
-
- }catch(InvalidPositionException &e)
- {
- }
}
//dstream<<"Map::transformLiquids(): loopcount="<<loopcount<<std::endl;
}
+NodeMetadata* Map::getNodeMetadata(v3s16 p)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+ <<std::endl;
+ return NULL;
+ }
+ NodeMetadata *meta = block->m_node_metadata.get(p_rel);
+ return meta;
+}
+
+void Map::setNodeMetadata(v3s16 p, NodeMetadata *meta)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::setNodeMetadata(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_metadata.set(p_rel, meta);
+}
+
+void Map::removeNodeMetadata(v3s16 p)
+{
+ v3s16 blockpos = getNodeBlockPos(p);
+ v3s16 p_rel = p - blockpos*MAP_BLOCKSIZE;
+ MapBlock *block = getBlockNoCreateNoEx(blockpos);
+ if(block == NULL)
+ {
+ dstream<<"WARNING: Map::removeNodeMetadata(): Block not found"
+ <<std::endl;
+ return;
+ }
+ block->m_node_metadata.remove(p_rel);
+}
+
/*
ServerMap
*/
//m_chunksize = 64;
//m_chunksize = 16; // Too slow
- //m_chunksize = 8; // Takes a few seconds
- m_chunksize = 4; // Too small?
+ m_chunksize = 8; // Takes a few seconds
+ //m_chunksize = 4;
//m_chunksize = 2;
// TODO: Save to and load from a file
MapNode treenode(CONTENT_TREE);
MapNode leavesnode(CONTENT_LEAVES);
- 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<trunk_h; ii++)
{
return 0.04 * (noise-zeroval) / (1.0-zeroval);
}
-#define AVERAGE_MUD_AMOUNT 4.0
-
-double get_mud_amount(u64 seed, v2f p)
-{
- return ((float)AVERAGE_MUD_AMOUNT + 3.0 * noise2d_perlin(
- 0.5+p.X/200, 0.5+p.Y/200,
- seed+1, 5, 0.65));
-}
-
-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);
-}
-
-// -1->0, 0->1, 1->0
-double contour(double v)
-{
- v = fabs(v);
- if(v >= 1.0)
- return 0.0;
- return (1.0-v);
-}
-
-// -1->0, -r->1, 0->1, r->1, 1->0
-double contour_flat_top(double v, double r)
-{
- 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));
-}
+#define AVERAGE_MUD_AMOUNT 4
-double base_rock_level_2d(u64 seed, v2f p)
+double base_rock_level_2d(u64 seed, v2s16 p)
{
- // 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
- {
- // 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
-
-#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
-
-#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
-
-#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
-
- /*
- The sutff before this comment is usually not used.
- The stuff after this comment is usually used.
- */
-
-#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
-
-#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
-
-#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.
- */
-
- 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(
+ // The base ground level
+ double base = (double)WATER_LEVEL - (double)AVERAGE_MUD_AMOUNT
+ + 25. * noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ (seed>>32)+654879876, 6, 0.6);
+
+ /*// A bit hillier one
+ double base2 = WATER_LEVEL - 4.0 + 40. * noise2d_perlin(
0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
- seed+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);
+ (seed>>27)+90340, 6, 0.69);
+ if(base2 > base)
+ base = base2;*/
#if 1
- b = pow(b, 5);
- b *= 16;
- b = rangelim(b, 3.0, 1000.0);
- //dstream<<"b="<<b<<std::endl;
- //double b = 20;
- // Offset to more low
- //double a_off = -0.30;
- double a_off = -0.20;
- // High/low selector
- double a = (double)0.5 + b * (a_off + noise2d_perlin(
- 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
- seed-359, 7, 0.70));
-#endif
-#if 0
- /*b = pow(b, 5);
- b *= 2;
- b = rangelim(b, 3.0, 20.0);*/
- //b = 10.0;
- double a = -1.5 + 5.0 * (noise2d_perlin_abs(
- 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
- seed-359, 6, 0.6));
- a *= 3.0;
- /*double a = 5.0 * (noise2d_perlin(
- 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
- seed-359, 5, 0.6));*/
- //a = contour_flat_top(a, 0.2);
-#endif
- // Limit
- a = rangelim(a, 0.0, 1.0);
- a = easeCurve(a);
-
- //dstream<<"a="<<a<<std::endl;
+ // Higher ground level
+ double higher = (double)WATER_LEVEL + 25. + 45. * noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed+85039, 5, 0.69);
+ //higher = 30; // For debugging
- /*double h2 = higher * a;
- if(h2 > h)
- h = h2;*/
+ // Limit higher to at least base
+ if(higher < base)
+ higher = base;
- 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));
-}
-
-v2f base_ground_turbulence(u64 seed, v3f p)
-{
-#if 1
- double f = 20;
-
-#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
-
-#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="<<vve<<std::endl;
-
- /*// Limit turbulence near water level
- double a = contour((p.Y-WATER_LEVEL)/10.0);
- vve = (1.-a) * vve;*/
-
- // Increase turbulence in elevated heights
- double ah = WATER_LEVEL + 40;
- if(p.Y > ah)
- {
- vve *= p.Y/ah;
- }
-#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);
+ // Steepness factor of cliffs
+ double b = 1.0 + 1.0 * noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed-932, 7, 0.7);
+ b = rangelim(b, 0.0, 1000.0);
+ b = pow(b, 5);
+ b *= 7;
+ b = rangelim(b, 3.0, 1000.0);
+ //dstream<<"b="<<b<<std::endl;
+ //double b = 20;
+
+ // Offset to more low
+ double a_off = -0.2;
+ // High/low selector
+ /*double a = 0.5 + b * (a_off + noise2d_perlin(
+ 0.5+(float)p.X/500., 0.5+(float)p.Y/500.,
+ seed-359, 6, 0.7));*/
+ double a = (double)0.5 + b * (a_off + noise2d_perlin(
+ 0.5+(float)p.X/250., 0.5+(float)p.Y/250.,
+ seed-359, 5, 0.60));
+ // Limit
+ a = rangelim(a, 0.0, 1.0);
- 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);
+ //dstream<<"a="<<a<<std::endl;
- return v2f(v1*vve, v2*vve);
+ double h = base*(1.0-a) + higher*a;
#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
-
- 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;
+ double h = base;
#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;
+ return h;
}
#define VMANIP_FLAG_DUNGEON VOXELFLAG_CHECKED1
{
DSTACK(__FUNCTION_NAME);
- // Shall be not used now
- //assert(0);
-
-#if 0
-
/*
Don't generate if already fully generated
*/
{
// 22ms @cs=8
- TimeTaker timer1("ground level");
- dstream<<"Generating base ground..."<<std::endl;
+ //TimeTaker timer1("ground level");
for(s16 x=0; x<sectorpos_bigbase_size*MAP_BLOCKSIZE; x++)
for(s16 z=0; z<sectorpos_bigbase_size*MAP_BLOCKSIZE; z++)
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;
- }
-
- v2f p2df(p2d.X, p2d.Y);
-
- {
- // Use fast index incrementing
- v3s16 em = vmanip.m_area.getExtent();
- s16 min = y_nodes_min;
- s16 max = y_nodes_max;
- /*s16 min = -10;
- s16 max = 20;*/
- //float surface_y_f = base_rock_level_2d(m_seed, p2df);
- u32 i = vmanip.m_area.index(v3s16(p2d.X, min, p2d.Y));
- for(s16 y=min; y<=max; y++)
- {
-#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
-#if 0
- double v = noise3d_perlin(
- 0.5+(float)p2d.X/200,
- 0.5+(float)y/200,
- 0.5+(float)p2d.Y/200,
- m_seed+293, 6, 0.55);
- if(v > 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
+ Skip of already generated
*/
{
v3s16 p(p2d.X, y_nodes_min, p2d.Y);
vmanip.m_area.add_y(em, i, 1);
}
}
-#endif
}
}//timer1
/*
Loop this part, it will make stuff look older and newer nicely
*/
- u32 age_count = 2;
- for(u32 i_age=0; i_age<age_count; i_age++)
+ //for(u32 i_age=0; i_age<1; i_age++)
+ for(u32 i_age=0; i_age<2; i_age++)
{ // Aging loop
{
v2s16 p2d = 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 = (s16)(2.5 + 2.0 * noise2d_perlin(
+ 0.5+(float)p2d.X/200, 0.5+(float)p2d.Y/200,
+ m_seed+1, 3, 0.55));
// Find ground level
s16 surface_y = find_ground_level_clever(vmanip, p2d);
}//timer1
{
// 340ms @cs=8
- //TimeTaker timer1("flow mud");
+ TimeTaker timer1("flow mud");
/*
Flow mud away from steep edges
v2s16 p2d = 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,
+ m_seed+59420, 3, 0.50);
+
+ bool have_sand = (sandnoise > -0.15);
if(have_sand == false)
continue;
// 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
}
#endif
- }//timer1
-
- // Spread light around
+#if 0
+ for(s16 x=lighting_min_d+1;
+ x<=lighting_max_d-1;
+ x++)
+ for(s16 z=lighting_min_d+1;
+ z<=lighting_max_d-1;
+ z++)
{
- TimeTaker timer("generateChunkRaw() spreadLight");
- vmanip.spreadLight(LIGHTBANK_DAY, light_sources);
- }
-
- /*
+ // Node position in 2d
+ v2s16 p2d = sectorpos_base*MAP_BLOCKSIZE + v2s16(x,z);
+
+ /*
+ Apply initial sunlight
+ */
+ {
+ u8 light = LIGHT_SUN;
+ v3s16 em = vmanip.m_area.getExtent();
+ s16 y_start = y_nodes_max;
+ u32 i = vmanip.m_area.index(v3s16(p2d.X, y_start, p2d.Y));
+ for(s16 y=y_start; y>=y_nodes_min; y--)
+ {
+ MapNode *n = &vmanip.m_data[i];
+
+ if(light_propagates_content(n->d) == false)
+ {
+ light = 0;
+ }
+ else if(light != LIGHT_SUN
+ || sunlight_propagates_content(n->d) == false)
+ {
+ if(light > 0)
+ light--;
+ }
+
+ n->setLight(LIGHTBANK_DAY, light);
+ n->setLight(LIGHTBANK_NIGHT, 0);
+
+ // This doesn't take much time
+ if(light != 0)
+ {
+ // Insert light source
+ light_sources.insert(v3s16(p2d.X, y, p2d.Y), true);
+ }
+
+ // Increment index by y
+ vmanip.m_area.add_y(em, i, -1);
+ }
+ }
+ }
+#endif
+
+ }//timer1
+
+ // Spread light around
+ {
+ TimeTaker timer("generateChunkRaw() spreadLight");
+ vmanip.spreadLight(LIGHTBANK_DAY, light_sources);
+ }
+
+ /*
Generation ended
*/
}
}
-#endif
/*
Create chunk metadata
<<"("<<chunkpos1.X<<","<<chunkpos1.Y<<")"
<<std::endl;
- // Shall be not used now
- //assert(0);
-
/*for(s16 x=-1; x<=1; x++)
for(s16 y=-1; y<=1; y++)*/
for(s16 x=-0; x<=0; x++)
<<p2d.X<<","<<p2d.Y<<" and chunk is already generated. "
<<std::endl;
+#if 0
+ dstream<<"WARNING: Creating an empty sector."<<std::endl;
+
+ return createSector(p2d);
+
+#endif
+
#if 1
dstream<<"WARNING: Forcing regeneration of chunk."<<std::endl;
dstream<<"ERROR: Could not get sector from anywhere."<<std::endl;
- //assert(0);
-#endif
-
-#if 1
- dstream<<"WARNING: Creating an empty sector."<<std::endl;
-
- return createSector(p2d);
-
+ assert(0);
#endif
/*
v2s16 p2d(p.X, p.Z);
s16 block_y = p.Y;
v2s16 p2d_nodes = p2d * MAP_BLOCKSIZE;
- v3s16 p_nodes = p * MAP_BLOCKSIZE;
/*
Do not generate over-limit
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.
- */
-
+
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
{
- /*
- 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<sizeof(checklist)/sizeof(checklist[0]); i++)
- {
- 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;
+ //dstream<<"generateBlock: x0="<<x0<<", z0="<<z0<<std::endl;
- 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;
- }
+ //s16 surface_y = 0;
- float block_low_y_f = p_nodes_f.Y;
- float block_high_y_f = p_nodes_f.Y + MAP_BLOCKSIZE;
+ s16 surface_y = base_rock_level_2d(m_seed, p2d_nodes+v2s16(x0,z0))
+ + AVERAGE_MUD_AMOUNT;
- /*dstream<<"surface_y_max="<<surface_y_max
- <<", surface_y_min="<<surface_y_min
- <<", block_low_y_f="<<block_low_y_f
- <<", block_high_y_f="<<block_high_y_f
- <<std::endl;*/
-
- // A fuzzyness value
- // Must accomodate mud and turbulence holes
- float d_down = 16;
- // Must accomodate a bit less
- float d_up = 5;
+ if(surface_y < lowest_ground_y)
+ lowest_ground_y = surface_y;
+ if(surface_y > highest_ground_y)
+ highest_ground_y = surface_y;
- if(block_high_y_f < surface_y_min - d_down)
- {
- //dstream<<"BT_GROUND"<<std::endl;
- // A ground block
- block_type = BT_GROUND;
- }
- else if(block_low_y_f >= surface_y_max + d_up
- && block_low_y_f > WATER_LEVEL + d_up)
- {
- //dstream<<"BT_SKY"<<std::endl;
- // A sky block
- block_type = BT_SKY;
- }
- else
- {
- //dstream<<"BT_SURFACE"<<std::endl;
- // A surface block
- block_type = BT_SURFACE;
- }
-
- if(/*block_type == BT_GROUND ||*/ block_type == BT_SKY)
- {
- lowest_ground_y = surface_y_min;
- highest_ground_y = surface_y_max;
- }
- }
-
- if(block_type == BT_SURFACE || block_type == BT_GROUND)
- {
- /*
- Generate ground precisely
- */
+ s32 surface_depth = AVERAGE_MUD_AMOUNT;
- for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
- for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
{
- //dstream<<"generateBlock: x0="<<x0<<", z0="<<z0<<std::endl;
-
- //s16 surface_y = 0;
-
- /*s16 surface_y = base_rock_level_2d(m_seed, p2d_nodes+v2s16(x0,z0))
- + AVERAGE_MUD_AMOUNT;
-
- if(surface_y < lowest_ground_y)
- lowest_ground_y = surface_y;
- if(surface_y > highest_ground_y)
- highest_ground_y = surface_y;*/
+ s16 real_y = block_y * MAP_BLOCKSIZE + y0;
+ MapNode n;
+ /*
+ Calculate lighting
+
+ NOTE: If there are some man-made structures above the
+ newly created block, they won't be taken into account.
+ */
+ if(real_y > surface_y)
+ n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
- v2s16 real_p2d = v2s16(x0,z0) + p2d*MAP_BLOCKSIZE;
+ /*
+ Calculate material
+ */
- //s32 surface_depth = AVERAGE_MUD_AMOUNT;
- s16 surface_depth = get_mud_amount(m_seed, v2f(real_p2d.X,real_p2d.Y));
-
- for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+ // If node is over heightmap y, it's air or water
+ if(real_y > surface_y)
{
- #if 1
- s16 real_y = block_y * MAP_BLOCKSIZE + y0;
- v3s16 real_pos = v3s16(x0,y0,z0) + p_nodes;
- MapNode n;
- /*
- Calculate lighting
-
- NOTE: If there are some man-made structures above the
- newly created block, they won't be taken into account.
- */
- /*if(real_y > surface_y)
- n.setLight(LIGHTBANK_DAY, LIGHT_SUN);*/
-
- /*
- Calculate material
- */
-
- v3f real_pos_f = intToFloat(real_pos, 1);
- v2f real_pos_f_2d(real_pos_f.X, real_pos_f.Z);
- double depth_guess;
- bool is_ground = is_base_ground(m_seed,
- real_pos_f, &depth_guess);
-
- // Estimate the surface height
- float surface_y_f = (float)real_y + depth_guess;
- s16 surface_y = real_y + depth_guess;
-
- // Get 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;
-
- // 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)
{
- // If under water level, it's water
- if(real_y < WATER_LEVEL)
- {
- n.d = water_material;
- n.setLight(LIGHTBANK_DAY,
- diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
- /*
- 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;
+ n.d = water_material;
+ n.setLight(LIGHTBANK_DAY,
+ diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
+ /*
+ Add to transforming liquid queue (in case it'd
+ start flowing)
+ */
+ v3s16 real_pos = v3s16(x0,y0,z0) + p*MAP_BLOCKSIZE;
+ m_transforming_liquid.push_back(real_pos);
}
- // Else it's ground or dungeons (air)
+ // else air
else
+ n.d = CONTENT_AIR;
+ }
+ // Else it's ground or dungeons (air)
+ else
+ {
+ // If it's surface_depth under ground, it's stone
+ if(real_y <= surface_y - surface_depth)
{
- // If it's surface_depth under ground, it's stone
- if((float)real_y <= surface_y_f - surface_depth - 0.75)
- {
- if(is_underground_mud(m_seed, real_pos_f))
- n.d = CONTENT_MUD;
- else
- n.d = CONTENT_STONE;
- }
- else if(surface_y_f <= WATER_LEVEL + 2.1
- && get_have_sand(m_seed, real_pos_f_2d))
+ n.d = CONTENT_STONE;
+ }
+ else
+ {
+ // It is mud if it is under the first ground
+ // level or under water
+ if(real_y < WATER_LEVEL || real_y <= surface_y - 1)
{
- n.d = CONTENT_SAND;
+ n.d = CONTENT_MUD;
}
else
{
- /*// It is mud if it is under the first ground
- // level or under water
- if(real_y < WATER_LEVEL || real_y <= surface_y - 1)
- {
- n.d = CONTENT_MUD;
- }
- else
- {
- n.d = CONTENT_GRASS;
- }*/
-
- n.d = CONTENT_MUD;
-
- /*// If under water level, it's mud
- if(real_y < WATER_LEVEL)
- n.d = CONTENT_MUD;
- // Only the topmost node is grass
- else if(real_y <= surface_y - 1)
- n.d = CONTENT_MUD;
- else
- n.d = CONTENT_GRASS;*/
+ n.d = CONTENT_GRASS;
}
- }
- block->setNode(v3s16(x0,y0,z0), n);
- #endif
- #if 0
- s16 real_y = block_y * MAP_BLOCKSIZE + y0;
- MapNode n;
- /*
- Calculate lighting
+ //n.d = CONTENT_MUD;
- NOTE: If there are some man-made structures above the
- newly created block, they won't be taken into account.
- */
- if(real_y > surface_y)
- n.setLight(LIGHTBANK_DAY, LIGHT_SUN);
-
- /*
- Calculate material
- */
-
- // If node is over heightmap y, it's air or water
- if(real_y > surface_y)
- {
- // If under water level, it's water
+ /*// If under water level, it's mud
if(real_y < WATER_LEVEL)
- {
- n.d = water_material;
- n.setLight(LIGHTBANK_DAY,
- diminish_light(LIGHT_SUN, WATER_LEVEL-real_y+1));
- /*
- Add to transforming liquid queue (in case it'd
- start flowing)
- */
- v3s16 real_pos = v3s16(x0,y0,z0) + p*MAP_BLOCKSIZE;
- m_transforming_liquid.push_back(real_pos);
- }
- // else air
- else
- n.d = CONTENT_AIR;
- }
- // Else it's ground or dungeons (air)
- else
- {
- // If it's surface_depth under ground, it's stone
- if(real_y <= surface_y - surface_depth)
- {
- n.d = CONTENT_STONE;
- }
+ n.d = CONTENT_MUD;
+ // Only the topmost node is grass
+ else if(real_y <= surface_y - 1)
+ n.d = CONTENT_MUD;
else
- {
- // It is mud if it is under the first ground
- // level or under water
- if(real_y < WATER_LEVEL || real_y <= surface_y - 1)
- {
- n.d = CONTENT_MUD;
- }
- else
- {
- n.d = CONTENT_GRASS;
- }
-
- //n.d = CONTENT_MUD;
-
- /*// If under water level, it's mud
- if(real_y < WATER_LEVEL)
- n.d = CONTENT_MUD;
- // Only the topmost node is grass
- else if(real_y <= surface_y - 1)
- n.d = CONTENT_MUD;
- else
- n.d = CONTENT_GRASS;*/
- }
+ n.d = CONTENT_GRASS;*/
}
-
- block->setNode(v3s16(x0,y0,z0), n);
- #endif
}
- }
- }// BT_SURFACE
- else // BT_GROUND, 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
- {
- n_fill.d = CONTENT_MESE;
- }
-
- for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
- for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
- for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
- {
- //MapNode n = block->getNode(v3s16(x0,y0,z0));
- block->setNode(v3s16(x0,y0,z0), n_fill);
+ block->setNode(v3s16(x0,y0,z0), n);
}
}
- }// ground_timer
-
/*
Calculate some helper variables
*/
//dstream<<"generateBlock(): Getting local attributes"<<std::endl;
- //float caves_amount = 0.5;
+ float caves_amount = 0.5;
#if 0
{
//dstream<<"generateBlock(): Done"<<std::endl;
-#if 0
- // Set to true if has caves.
- // Set when some non-air is changed to air when making caves.
- bool has_dungeons = false;
-
/*
Generate dungeons
*/
}
// Fill table
-#if 0
+#if 1
{
/*
Initialize orp and ors. Try to find if some neighboring
// Partly underground = cave
else if(!completely_underground)
{
- //do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
- do_generate_dungeons = false;
+ do_generate_dungeons = (rand() % 100 <= (s32)(caves_amount*100));
}
// Found existing dungeon underground
else if(found_existing && completely_underground)
}
#endif
+ // Set to true if has caves.
+ // Set when some non-air is changed to air when making caves.
+ bool has_dungeons = false;
+
/*
Apply temporary cave data to block
*/
block->setNode(v3s16(x0,y0,z0), n);
}
}
-#endif
/*
This is used for guessing whether or not the block should
/*
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)
/*
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)
}
/*
- 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; i<tree_count/2; i++)
- {
- v3s16 tree_p = p_nodes + v3s16(
- myrand_range(0,MAP_BLOCKSIZE-1),
- 8,
- myrand_range(0,MAP_BLOCKSIZE-1)
- );
- double depth_guess;
- /*bool is_ground =*/ is_base_ground(m_seed,
- intToFloat(tree_p, 1), &depth_guess);
- tree_p.Y += (depth_guess - 0.5);
- if(tree_p.Y <= WATER_LEVEL)
- continue;
- make_tree(vm, tree_p);
- }
-
- vm.blitBack(changed_blocks);
- }
-#endif
+ // Lighting is invalid after generation.
+ block->setLightingExpired(true);
#if 0
/*
if(does_not_exist)
{
block = generateBlock(p, block, sector, changed_blocks,
- lighting_invalidated_blocks);
-
- lighting_expired = block->getLightingExpired();
+ lighting_invalidated_blocks);
}
if(lighting_expired)
Initially update sunlight
*/
- if(lighting_expired)
{
core::map<v3s16, bool> light_sources;
bool black_air_left = false;
*/
int time1 = time(0);
- u32 daynight_ratio = m_client->getDayNightRatio();
+ //u32 daynight_ratio = m_client->getDayNightRatio();
m_camera_mutex.Lock();
v3f camera_position = m_camera_position;
continue;
}
- // This is ugly
+ // This is ugly (spherical distance limit?)
/*if(m_control.range_all == false &&
d - 0.5*BS*MAP_BLOCKSIZE > range)
continue;*/
#if 1
/*
Update expired mesh (used for day/night change)
+
+ It doesn't work exactly like it should now with the
+ tasked mesh update but whatever.
*/
bool mesh_expired = false;
mesh_update_count++;
// Mesh has been expired: generate new mesh
- //block->updateMeshes(daynight_i);
- block->updateMesh(daynight_ratio);
+ //block->updateMesh(daynight_ratio);
+ m_client->addUpdateMeshTask(block->getPos());
mesh_expired = false;
}
- /*
- Don't draw an expired mesh that is far away
- */
- /*if(mesh_expired && d >= faraway)
- //if(mesh_expired)
- {
- // Instead, delete it
- JMutexAutoLock lock(block->mesh_mutex);
- if(block->mesh)
- {
- block->mesh->drop();
- block->mesh = NULL;
- }
- // And continue to next block
- continue;
- }*/
#endif
/*
Draw the faces of the block
v3s16 p = blockpos + v3s16(0,0,0);
MapBlock *b = getBlockNoCreate(p);
b->updateMesh(daynight_ratio);
+ //b->setMeshExpired(true);
}
catch(InvalidPositionException &e){}
// Leading edge
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; j<i; j++)
+ {
+ if(blockposes[j] == blockposes[i])
+ {
+ already_updated = true;
+ break;
+ }
+ }
+ if(already_updated)
+ continue;
+ // Update mesh
+ MapBlock *b = getBlockNoCreate(blockposes[i]);
b->updateMesh(daynight_ratio);
}
- catch(InvalidPositionException &e){}*/
}
+#endif
void ClientMap::PrintInfo(std::ostream &out)
{