3 Copyright (C) 2016-2017 Duane Robertson <duane@duanerobertson.com>
4 Copyright (C) 2016-2017 paramat
6 Based on Valleys Mapgen by Gael de Sailly
7 (https://forum.minetest.net/viewtopic.php?f=9&t=11430)
8 and mapgen_v7, mapgen_flat by kwolekr and paramat.
10 Licensing changed by permission of Gael de Sailly.
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU Lesser General Public License as published by
14 the Free Software Foundation; either version 2.1 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU Lesser General Public License for more details.
22 You should have received a copy of the GNU Lesser General Public License along
23 with this program; if not, write to the Free Software Foundation, Inc.,
24 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
33 #include "content_sao.h"
35 #include "voxelalgorithms.h"
36 #include "settings.h" // For g_settings
38 #include "dungeongen.h"
41 #include "mg_decoration.h"
42 #include "mapgen_valleys.h"
49 //#include "util/timetaker.h"
50 //#include "profiler.h"
53 //static Profiler mapgen_prof;
54 //Profiler *mapgen_profiler = &mapgen_prof;
56 static FlagDesc flagdesc_mapgen_valleys[] = {
57 {"altitude_chill", MGVALLEYS_ALT_CHILL},
58 {"humid_rivers", MGVALLEYS_HUMID_RIVERS},
62 ///////////////////////////////////////////////////////////////////////////////
65 MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeManager *emerge)
66 : MapgenBasic(mapgenid, params, emerge)
68 // NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal
69 m_bgen = (BiomeGenOriginal *)biomegen;
71 BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
73 spflags = params->spflags;
74 altitude_chill = params->altitude_chill;
75 large_cave_depth = params->large_cave_depth;
76 lava_features_lim = rangelim(params->lava_features, 0, 10);
77 massive_cave_depth = params->massive_cave_depth;
78 river_depth_bed = params->river_depth + 1.f;
79 river_size_factor = params->river_size / 100.f;
80 water_features_lim = rangelim(params->water_features, 0, 10);
81 cave_width = params->cave_width;
84 noise_filler_depth = new Noise(¶ms->np_filler_depth, seed, csize.X, csize.Z);
85 noise_inter_valley_slope = new Noise(¶ms->np_inter_valley_slope, seed, csize.X, csize.Z);
86 noise_rivers = new Noise(¶ms->np_rivers, seed, csize.X, csize.Z);
87 noise_terrain_height = new Noise(¶ms->np_terrain_height, seed, csize.X, csize.Z);
88 noise_valley_depth = new Noise(¶ms->np_valley_depth, seed, csize.X, csize.Z);
89 noise_valley_profile = new Noise(¶ms->np_valley_profile, seed, csize.X, csize.Z);
92 // 1-up 1-down overgeneration
93 noise_inter_valley_fill = new Noise(¶ms->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
94 // 1-down overgeneraion
95 noise_cave1 = new Noise(¶ms->np_cave1, seed, csize.X, csize.Y + 1, csize.Z);
96 noise_cave2 = new Noise(¶ms->np_cave2, seed, csize.X, csize.Y + 1, csize.Z);
97 noise_massive_caves = new Noise(¶ms->np_massive_caves, seed, csize.X, csize.Y + 1, csize.Z);
99 humid_rivers = (spflags & MGVALLEYS_HUMID_RIVERS);
100 use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
101 humidity_adjust = bp->np_humidity.offset - 50.f;
103 // a small chance of overflows if the settings are very high
104 cave_water_max_height = water_level + MYMAX(0, water_features_lim - 4) * 50;
105 lava_max_height = water_level + MYMAX(0, lava_features_lim - 4) * 50;
107 tcave_cache = new float[csize.Y + 2];
111 MapgenValleys::~MapgenValleys()
115 delete noise_filler_depth;
116 delete noise_inter_valley_fill;
117 delete noise_inter_valley_slope;
119 delete noise_massive_caves;
120 delete noise_terrain_height;
121 delete noise_valley_depth;
122 delete noise_valley_profile;
124 delete[] tcave_cache;
128 MapgenValleysParams::MapgenValleysParams()
130 np_cave1 = NoiseParams(0, 12, v3f(61, 61, 61), 52534, 3, 0.5, 2.0);
131 np_cave2 = NoiseParams(0, 12, v3f(67, 67, 67), 10325, 3, 0.5, 2.0);
132 np_filler_depth = NoiseParams(0.f, 1.2f, v3f(256, 256, 256), 1605, 3, 0.5f, 2.f);
133 np_inter_valley_fill = NoiseParams(0.f, 1.f, v3f(256, 512, 256), 1993, 6, 0.8f, 2.f);
134 np_inter_valley_slope = NoiseParams(0.5f, 0.5f, v3f(128, 128, 128), 746, 1, 1.f, 2.f);
135 np_rivers = NoiseParams(0.f, 1.f, v3f(256, 256, 256), -6050, 5, 0.6f, 2.f);
136 np_massive_caves = NoiseParams(0.f, 1.f, v3f(768, 256, 768), 59033, 6, 0.63f, 2.f);
137 np_terrain_height = NoiseParams(-10.f, 50.f, v3f(1024, 1024, 1024), 5202, 6, 0.4f, 2.f);
138 np_valley_depth = NoiseParams(5.f, 4.f, v3f(512, 512, 512), -1914, 1, 1.f, 2.f);
139 np_valley_profile = NoiseParams(0.6f, 0.5f, v3f(512, 512, 512), 777, 1, 1.f, 2.f);
143 void MapgenValleysParams::readParams(const Settings *settings)
145 settings->getFlagStrNoEx("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys);
146 settings->getU16NoEx("mgvalleys_altitude_chill", altitude_chill);
147 settings->getS16NoEx("mgvalleys_large_cave_depth", large_cave_depth);
148 settings->getU16NoEx("mgvalleys_lava_features", lava_features);
149 settings->getS16NoEx("mgvalleys_massive_cave_depth", massive_cave_depth);
150 settings->getU16NoEx("mgvalleys_river_depth", river_depth);
151 settings->getU16NoEx("mgvalleys_river_size", river_size);
152 settings->getU16NoEx("mgvalleys_water_features", water_features);
153 settings->getFloatNoEx("mgvalleys_cave_width", cave_width);
155 settings->getNoiseParams("mgvalleys_np_cave1", np_cave1);
156 settings->getNoiseParams("mgvalleys_np_cave2", np_cave2);
157 settings->getNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
158 settings->getNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
159 settings->getNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
160 settings->getNoiseParams("mgvalleys_np_rivers", np_rivers);
161 settings->getNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
162 settings->getNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
163 settings->getNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
164 settings->getNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
168 void MapgenValleysParams::writeParams(Settings *settings) const
170 settings->setFlagStr("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys, U32_MAX);
171 settings->setU16("mgvalleys_altitude_chill", altitude_chill);
172 settings->setS16("mgvalleys_large_cave_depth", large_cave_depth);
173 settings->setU16("mgvalleys_lava_features", lava_features);
174 settings->setS16("mgvalleys_massive_cave_depth", massive_cave_depth);
175 settings->setU16("mgvalleys_river_depth", river_depth);
176 settings->setU16("mgvalleys_river_size", river_size);
177 settings->setU16("mgvalleys_water_features", water_features);
178 settings->setFloat("mgvalleys_cave_width", cave_width);
180 settings->setNoiseParams("mgvalleys_np_cave1", np_cave1);
181 settings->setNoiseParams("mgvalleys_np_cave2", np_cave2);
182 settings->setNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
183 settings->setNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
184 settings->setNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
185 settings->setNoiseParams("mgvalleys_np_rivers", np_rivers);
186 settings->setNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
187 settings->setNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
188 settings->setNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
189 settings->setNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
193 ///////////////////////////////////////
196 void MapgenValleys::makeChunk(BlockMakeData *data)
199 assert(data->vmanip);
200 assert(data->nodedef);
201 assert(data->blockpos_requested.X >= data->blockpos_min.X &&
202 data->blockpos_requested.Y >= data->blockpos_min.Y &&
203 data->blockpos_requested.Z >= data->blockpos_min.Z);
204 assert(data->blockpos_requested.X <= data->blockpos_max.X &&
205 data->blockpos_requested.Y <= data->blockpos_max.Y &&
206 data->blockpos_requested.Z <= data->blockpos_max.Z);
208 this->generating = true;
209 this->vm = data->vmanip;
210 this->ndef = data->nodedef;
212 //TimeTaker t("makeChunk");
214 v3s16 blockpos_min = data->blockpos_min;
215 v3s16 blockpos_max = data->blockpos_max;
216 node_min = blockpos_min * MAP_BLOCKSIZE;
217 node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
218 full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
219 full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
221 blockseed = getBlockSeed2(full_node_min, seed);
223 // Generate biome noises. Note this must be executed strictly before
224 // generateTerrain, because generateTerrain depends on intermediate
225 // biome-related noises.
226 m_bgen->calcBiomeNoise(node_min);
228 // Generate noise maps and base terrain height.
229 // Modify heat and humidity maps.
232 // Generate base terrain with initial heightmaps
233 s16 stone_surface_max_y = generateTerrain();
235 // Recalculate heightmap
236 updateHeightmap(node_min, node_max);
238 // Place biome-specific nodes and build biomemap
239 MgStoneType mgstone_type;
240 content_t biome_stone;
241 generateBiomes(&mgstone_type, &biome_stone, water_level - 1);
244 if (flags & MG_CAVES)
245 generateCaves(stone_surface_max_y, large_cave_depth);
248 if ((flags & MG_DUNGEONS) && node_max.Y < 50)
249 generateDungeons(stone_surface_max_y, mgstone_type, biome_stone);
251 // Generate the registered decorations
252 if (flags & MG_DECORATIONS)
253 m_emerge->decomgr->placeAllDecos(this, blockseed,
254 node_min, node_max, water_level - 1);
256 // Generate the registered ores
257 m_emerge->oremgr->placeAllOres(this, blockseed,
258 node_min, node_max, water_level - 1);
260 // Sprinkle some dust on top after everything else was generated
263 //TimeTaker tll("liquid_lighting");
265 updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);
267 if (flags & MG_LIGHT)
269 node_min - v3s16(0, 1, 0),
270 node_max + v3s16(0, 1, 0),
274 //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f);
275 //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f);
277 this->generating = false;
281 // Populate the noise tables and do most of the
282 // calculation necessary to determine terrain height.
283 void MapgenValleys::calculateNoise()
285 //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
288 int y = node_min.Y - 1;
291 //TimeTaker tcn("actualNoise");
293 noise_inter_valley_slope->perlinMap2D(x, z);
294 noise_rivers->perlinMap2D(x, z);
295 noise_terrain_height->perlinMap2D(x, z);
296 noise_valley_depth->perlinMap2D(x, z);
297 noise_valley_profile->perlinMap2D(x, z);
299 noise_inter_valley_fill->perlinMap3D(x, y, z);
301 //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
303 float heat_offset = 0.f;
304 float humidity_scale = 1.f;
306 // Altitude chill tends to reduce the average heat.
307 if (use_altitude_chill)
310 // River humidity tends to increase the humidity range.
312 humidity_scale = 0.8f;
315 for (s32 index = 0; index < csize.X * csize.Z; index++) {
316 m_bgen->heatmap[index] += heat_offset;
317 m_bgen->humidmap[index] *= humidity_scale;
323 for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++)
324 for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) {
325 // The parameters that we actually need to generate terrain
326 // are passed by address (and the return value).
327 tn.terrain_height = noise_terrain_height->result[index];
328 // River noise is replaced with base terrain, which
329 // is basically the height of the water table.
330 tn.rivers = &noise_rivers->result[index];
331 // Valley depth noise is replaced with the valley
332 // number that represents the height of terrain
333 // over rivers and is used to determine about
334 // how close a river is for humidity calculation.
335 tn.valley = &noise_valley_depth->result[index];
336 tn.valley_profile = noise_valley_profile->result[index];
337 // Slope noise is replaced by the calculated slope
338 // which is used to get terrain height in the slow
339 // method, to create sharper mountains.
340 tn.slope = &noise_inter_valley_slope->result[index];
341 tn.inter_valley_fill = noise_inter_valley_fill->result[index];
343 // This is the actual terrain height.
344 float mount = terrainLevelFromNoise(&tn);
345 noise_terrain_height->result[index] = mount;
350 // This keeps us from having to maintain two similar sets of
351 // complicated code to determine ground level.
352 float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
354 // The square function changes the behaviour of this noise:
355 // very often small, and sometimes very high.
356 float valley_d = MYSQUARE(*tn->valley);
358 // valley_d is here because terrain is generally higher where valleys
359 // are deep (mountains). base represents the height of the
360 // rivers, most of the surface is above.
361 float base = tn->terrain_height + valley_d;
363 // "river" represents the distance from the river, in arbitrary units.
364 float river = fabs(*tn->rivers) - river_size_factor;
366 // Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
367 // Making "a" vary (0 < a <= 1) changes the shape of the valleys.
368 // Try it with a geometry software !
369 // (here x = "river" and a = valley_profile).
370 // "valley" represents the height of the terrain, from the rivers.
372 float t = river / tn->valley_profile;
373 *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t)));
376 // approximate height of the terrain at this point
377 float mount = base + *tn->valley;
379 *tn->slope *= *tn->valley;
381 // Rivers are placed where "river" is negative, so where the original
382 // noise value is close to zero.
383 // Base ground is returned as rivers since it's basically the water table.
386 // Use the the function -sqrt(1-x^2) which models a circle.
389 float t = river / river_size_factor + 1;
390 depth = (river_depth_bed * sqrt(MYMAX(0, 1.f - MYSQUARE(t))));
393 // base - depth : height of the bottom of the river
394 // water_level - 3 : don't make rivers below 3 nodes under the surface
395 // We use three because that's as low as the swamp biomes go.
396 // There is no logical equivalent to this using rangelim.
397 mount = MYMIN(MYMAX(base - depth, (float)(water_level - 3)), mount);
399 // Slope has no influence on rivers.
407 // This avoids duplicating the code in terrainLevelFromNoise, adding
408 // only the final step of terrain generation without a noise map.
409 float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
411 float mount = terrainLevelFromNoise(tn);
412 s16 y_start = myround(mount);
414 for (s16 y = y_start; y <= y_start + 1000; y++) {
415 float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
417 if (fill * *tn->slope < y - mount) {
418 mount = MYMAX(y - 1, mount);
427 int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
429 // Check to make sure this isn't a request for a location in a river.
430 float rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
431 if (fabs(rivers) < river_size_factor)
432 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
434 s16 level_at_point = terrainLevelAtPoint(p.X, p.Y);
435 if (level_at_point <= water_level ||
436 level_at_point > water_level + 32)
437 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
439 return level_at_point;
443 float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
447 float rivers = NoisePerlin2D(&noise_rivers->np, x, z, seed);
448 float valley = NoisePerlin2D(&noise_valley_depth->np, x, z, seed);
449 float inter_valley_slope = NoisePerlin2D(&noise_inter_valley_slope->np, x, z, seed);
453 tn.terrain_height = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
456 tn.valley_profile = NoisePerlin2D(&noise_valley_profile->np, x, z, seed);
457 tn.slope = &inter_valley_slope;
458 tn.inter_valley_fill = 0.f;
460 return adjustedTerrainLevelFromNoise(&tn);
464 int MapgenValleys::generateTerrain()
466 // Raising this reduces the rate of evaporation.
467 static const float evaporation = 300.f;
469 static const float humidity_dropoff = 4.f;
470 // constant to convert altitude chill (compatible with lua) to heat
471 static const float alt_to_heat = 20.f;
472 // humidity reduction by altitude
473 static const float alt_to_humid = 10.f;
475 MapNode n_air(CONTENT_AIR);
476 MapNode n_river_water(c_river_water_source);
477 MapNode n_stone(c_stone);
478 MapNode n_water(c_water_source);
480 const v3s16 &em = vm->m_area.getExtent();
481 s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
484 for (s16 z = node_min.Z; z <= node_max.Z; z++)
485 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
486 float river_y = noise_rivers->result[index_2d];
487 float surface_y = noise_terrain_height->result[index_2d];
488 float slope = noise_inter_valley_slope->result[index_2d];
489 float t_heat = m_bgen->heatmap[index_2d];
491 heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
493 if (surface_y > surface_max_y)
494 surface_max_y = ceil(surface_y);
497 // Derive heat from (base) altitude. This will be most correct
498 // at rivers, since other surface heights may vary below.
499 if (use_altitude_chill && (surface_y > 0.f || river_y > 0.f))
500 t_heat -= alt_to_heat * MYMAX(surface_y, river_y) / altitude_chill;
502 // If humidity is low or heat is high, lower the water table.
503 float delta = m_bgen->humidmap[index_2d] - 50.f;
505 float t_evap = (t_heat - 32.f) / evaporation;
506 river_y += delta * MYMAX(t_evap, 0.08f);
510 u32 index_3d = (z - node_min.Z) * zstride_1u1d + (x - node_min.X);
511 u32 index_data = vm->m_area.index(x, node_min.Y - 1, z);
513 // Mapgens concern themselves with stone and water.
514 for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
515 if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
516 float fill = noise_inter_valley_fill->result[index_3d];
517 float surface_delta = (float)y - surface_y;
518 bool river = y + 1 < river_y;
520 if (slope * fill > surface_delta) {
522 vm->m_data[index_data] = n_stone;
523 if (y > heightmap[index_2d])
524 heightmap[index_2d] = y;
525 if (y > surface_max_y)
527 } else if (y <= water_level) {
529 vm->m_data[index_data] = n_water;
532 vm->m_data[index_data] = n_river_water;
534 vm->m_data[index_data] = n_air;
538 vm->m_area.add_y(em, index_data, 1);
542 if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
543 s16 surface_y_int = myround(surface_y);
544 if (surface_y_int > node_max.Y + 1 || surface_y_int < node_min.Y - 1) {
545 // If surface_y is outside the chunk, it's good enough.
546 heightmap[index_2d] = surface_y_int;
548 // If the ground is outside of this chunk, but surface_y
549 // is within the chunk, give a value outside.
550 heightmap[index_2d] = node_min.Y - 2;
555 // Use base ground (water table) in a riverbed, to
556 // avoid an unnatural rise in humidity.
557 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
558 float humid = m_bgen->humidmap[index_2d];
559 float water_depth = (t_alt - river_y) / humidity_dropoff;
560 humid *= 1.f + pow(0.5f, MYMAX(water_depth, 1.f));
562 // Reduce humidity with altitude (ignoring riverbeds).
563 // This is similar to the lua version's seawater adjustment,
564 // but doesn't increase the base humidity, which causes
565 // problems with the default biomes.
567 humid -= alt_to_humid * t_alt / altitude_chill;
569 m_bgen->humidmap[index_2d] = humid;
572 // Assign the heat adjusted by any changed altitudes.
573 // The altitude will change about half the time.
574 if (use_altitude_chill) {
575 // ground height ignoring riverbeds
576 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
577 if (humid_rivers && heightmap[index_2d] == (s16)myround(surface_y))
578 // The altitude hasn't changed. Use the first result.
579 m_bgen->heatmap[index_2d] = t_heat;
580 else if (t_alt > 0.f)
581 m_bgen->heatmap[index_2d] -= alt_to_heat * t_alt / altitude_chill;
585 return surface_max_y;
588 void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth)
590 if (max_stone_y < node_min.Y)
593 noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
594 noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
596 PseudoRandom ps(blockseed + 72202);
598 MapNode n_air(CONTENT_AIR);
599 MapNode n_lava(c_lava_source);
600 MapNode n_water(c_river_water_source);
602 const v3s16 &em = vm->m_area.getExtent();
604 // Cave blend distance near YMIN, YMAX
605 const float massive_cave_blend = 128.f;
606 // noise threshold for massive caves
607 const float massive_cave_threshold = 0.6f;
608 // mct: 1 = small rare caves, 0.5 1/3rd ground volume, 0 = 1/2 ground volume.
610 float yblmin = -mapgen_limit + massive_cave_blend * 1.5f;
611 float yblmax = massive_cave_depth - massive_cave_blend * 1.5f;
612 bool made_a_big_one = false;
614 // Cache the tcave values as they only vary by altitude.
615 if (node_max.Y <= massive_cave_depth) {
616 noise_massive_caves->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
618 for (s16 y = node_min.Y - 1; y <= node_max.Y; y++) {
619 float tcave = massive_cave_threshold;
622 float t = (yblmin - y) / massive_cave_blend;
623 tcave += MYSQUARE(t);
624 } else if (y > yblmax) {
625 float t = (y - yblmax) / massive_cave_blend;
626 tcave += MYSQUARE(t);
629 tcave_cache[y - node_min.Y + 1] = tcave;
633 // lava_depth varies between one and ten as you approach
634 // the bottom of the world.
635 s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / mapgen_limit);
636 // This allows random lava spawns to be less common at the surface.
637 s16 lava_chance = MYCUBE(lava_features_lim) * lava_depth;
638 // water_depth varies between ten and one on the way down.
639 s16 water_depth = ceil((mapgen_limit - abs(node_min.Y) + 1) * 10.f / mapgen_limit);
640 // This allows random water spawns to be more common at the surface.
641 s16 water_chance = MYCUBE(water_features_lim) * water_depth;
643 // Reduce the odds of overflows even further.
644 if (node_max.Y > water_level) {
650 for (s16 z = node_min.Z; z <= node_max.Z; z++)
651 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
652 Biome *biome = (Biome *)m_bmgr->getRaw(biomemap[index_2d]);
653 bool tunnel_air_above = false;
654 bool is_under_river = false;
655 bool underground = false;
656 u32 index_data = vm->m_area.index(x, node_max.Y, z);
657 u32 index_3d = (z - node_min.Z) * zstride_1d + csize.Y * ystride + (x - node_min.X);
659 // Dig caves on down loop to check for air above.
660 // Don't excavate the overgenerated stone at node_max.Y + 1,
661 // this creates a 'roof' over the tunnel, preventing light in
662 // tunnels at mapchunk borders when generating mapchunks upwards.
663 // This 'roof' is removed when the mapchunk above is generated.
664 for (s16 y = node_max.Y; y >= node_min.Y - 1; y--,
666 vm->m_area.add_y(em, index_data, -1)) {
668 float terrain = noise_terrain_height->result[index_2d];
671 if (y > terrain + 10)
673 else if (y < terrain - 40)
676 // Dig massive caves.
677 if (node_max.Y <= massive_cave_depth
678 && noise_massive_caves->result[index_3d]
679 > tcave_cache[y - node_min.Y + 1]) {
680 vm->m_data[index_data] = n_air;
681 made_a_big_one = true;
685 content_t c = vm->m_data[index_data].getContent();
686 // Detect river water to place riverbed nodes in tunnels
687 if (c == biome->c_river_water)
688 is_under_river = true;
690 float d1 = contour(noise_cave1->result[index_3d]);
691 float d2 = contour(noise_cave2->result[index_3d]);
693 if (d1 * d2 > cave_width && ndef->get(c).is_ground_content) {
695 vm->m_data[index_data] = n_air;
696 tunnel_air_above = true;
697 } else if (c == biome->c_filler || c == biome->c_stone) {
698 if (tunnel_air_above) {
699 // at the tunnel floor
700 s16 sr = ps.range(0, 39);
702 vm->m_area.add_y(em, j, 1);
704 if (sr > terrain - y) {
705 // Put biome nodes in tunnels near the surface
707 vm->m_data[index_data] = MapNode(biome->c_riverbed);
708 else if (underground)
709 vm->m_data[index_data] = MapNode(biome->c_filler);
711 vm->m_data[index_data] = MapNode(biome->c_top);
712 } else if (sr < 3 && underground) {
714 if (lava_features_lim > 0 && y <= lava_max_height
715 && c == biome->c_stone && sr < lava_chance)
716 vm->m_data[j] = n_lava;
720 // If sr < 0 then we should have already placed lava --
721 // don't immediately dump water on it.
722 if (water_features_lim > 0 && y <= cave_water_max_height
723 && sr >= 0 && sr < water_chance)
724 vm->m_data[j] = n_water;
728 tunnel_air_above = false;
731 tunnel_air_above = false;
736 if (node_max.Y <= large_cave_depth && !made_a_big_one) {
737 u32 bruises_count = ps.range(0, 2);
738 for (u32 i = 0; i < bruises_count; i++) {
739 CavesRandomWalk cave(ndef, &gennotify, seed, water_level,
740 c_water_source, c_lava_source, lava_max_height);
742 cave.makeCave(vm, node_min, node_max, &ps, true, max_stone_y, heightmap);