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 this->m_bgen = (BiomeGenOriginal *)biomegen;
71 BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
73 this->spflags = params->spflags;
74 this->altitude_chill = params->altitude_chill;
75 this->large_cave_depth = params->large_cave_depth;
76 this->lava_features_lim = rangelim(params->lava_features, 0, 10);
77 this->massive_cave_depth = params->massive_cave_depth;
78 this->river_depth_bed = params->river_depth + 1.f;
79 this->river_size_factor = params->river_size / 100.f;
80 this->water_features_lim = rangelim(params->water_features, 0, 10);
81 this->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 this->humid_rivers = (spflags & MGVALLEYS_HUMID_RIVERS);
100 this->use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
101 this->humidity_adjust = bp->np_humidity.offset - 50.f;
103 // a small chance of overflows if the settings are very high
104 this->cave_water_max_height = water_level + MYMAX(0, water_features_lim - 4) * 50;
105 this->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 spflags = MGVALLEYS_HUMID_RIVERS | MGVALLEYS_ALT_CHILL;
131 altitude_chill = 90; // The altitude at which temperature drops by 20C.
132 large_cave_depth = -33;
133 lava_features = 0; // How often water will occur in caves.
134 massive_cave_depth = -256; // highest altitude of massive caves
135 river_depth = 4; // How deep to carve river channels.
136 river_size = 5; // How wide to make rivers.
137 water_features = 0; // How often water will occur in caves.
140 np_cave1 = NoiseParams(0, 12, v3f(61, 61, 61), 52534, 3, 0.5, 2.0);
141 np_cave2 = NoiseParams(0, 12, v3f(67, 67, 67), 10325, 3, 0.5, 2.0);
142 np_filler_depth = NoiseParams(0.f, 1.2f, v3f(256, 256, 256), 1605, 3, 0.5f, 2.f);
143 np_inter_valley_fill = NoiseParams(0.f, 1.f, v3f(256, 512, 256), 1993, 6, 0.8f, 2.f);
144 np_inter_valley_slope = NoiseParams(0.5f, 0.5f, v3f(128, 128, 128), 746, 1, 1.f, 2.f);
145 np_rivers = NoiseParams(0.f, 1.f, v3f(256, 256, 256), -6050, 5, 0.6f, 2.f);
146 np_massive_caves = NoiseParams(0.f, 1.f, v3f(768, 256, 768), 59033, 6, 0.63f, 2.f);
147 np_terrain_height = NoiseParams(-10.f, 50.f, v3f(1024, 1024, 1024), 5202, 6, 0.4f, 2.f);
148 np_valley_depth = NoiseParams(5.f, 4.f, v3f(512, 512, 512), -1914, 1, 1.f, 2.f);
149 np_valley_profile = NoiseParams(0.6f, 0.5f, v3f(512, 512, 512), 777, 1, 1.f, 2.f);
153 void MapgenValleysParams::readParams(const Settings *settings)
155 settings->getFlagStrNoEx("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys);
156 settings->getU16NoEx("mgvalleys_altitude_chill", altitude_chill);
157 settings->getS16NoEx("mgvalleys_large_cave_depth", large_cave_depth);
158 settings->getU16NoEx("mgvalleys_lava_features", lava_features);
159 settings->getS16NoEx("mgvalleys_massive_cave_depth", massive_cave_depth);
160 settings->getU16NoEx("mgvalleys_river_depth", river_depth);
161 settings->getU16NoEx("mgvalleys_river_size", river_size);
162 settings->getU16NoEx("mgvalleys_water_features", water_features);
163 settings->getFloatNoEx("mgvalleys_cave_width", cave_width);
165 settings->getNoiseParams("mgvalleys_np_cave1", np_cave1);
166 settings->getNoiseParams("mgvalleys_np_cave2", np_cave2);
167 settings->getNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
168 settings->getNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
169 settings->getNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
170 settings->getNoiseParams("mgvalleys_np_rivers", np_rivers);
171 settings->getNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
172 settings->getNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
173 settings->getNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
174 settings->getNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
178 void MapgenValleysParams::writeParams(Settings *settings) const
180 settings->setFlagStr("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys, U32_MAX);
181 settings->setU16("mgvalleys_altitude_chill", altitude_chill);
182 settings->setS16("mgvalleys_large_cave_depth", large_cave_depth);
183 settings->setU16("mgvalleys_lava_features", lava_features);
184 settings->setS16("mgvalleys_massive_cave_depth", massive_cave_depth);
185 settings->setU16("mgvalleys_river_depth", river_depth);
186 settings->setU16("mgvalleys_river_size", river_size);
187 settings->setU16("mgvalleys_water_features", water_features);
188 settings->setFloat("mgvalleys_cave_width", cave_width);
190 settings->setNoiseParams("mgvalleys_np_cave1", np_cave1);
191 settings->setNoiseParams("mgvalleys_np_cave2", np_cave2);
192 settings->setNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
193 settings->setNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
194 settings->setNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
195 settings->setNoiseParams("mgvalleys_np_rivers", np_rivers);
196 settings->setNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
197 settings->setNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
198 settings->setNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
199 settings->setNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
203 ///////////////////////////////////////
206 void MapgenValleys::makeChunk(BlockMakeData *data)
209 assert(data->vmanip);
210 assert(data->nodedef);
211 assert(data->blockpos_requested.X >= data->blockpos_min.X &&
212 data->blockpos_requested.Y >= data->blockpos_min.Y &&
213 data->blockpos_requested.Z >= data->blockpos_min.Z);
214 assert(data->blockpos_requested.X <= data->blockpos_max.X &&
215 data->blockpos_requested.Y <= data->blockpos_max.Y &&
216 data->blockpos_requested.Z <= data->blockpos_max.Z);
218 this->generating = true;
219 this->vm = data->vmanip;
220 this->ndef = data->nodedef;
222 //TimeTaker t("makeChunk");
224 v3s16 blockpos_min = data->blockpos_min;
225 v3s16 blockpos_max = data->blockpos_max;
226 node_min = blockpos_min * MAP_BLOCKSIZE;
227 node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
228 full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
229 full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
231 blockseed = getBlockSeed2(full_node_min, seed);
233 // Generate biome noises. Note this must be executed strictly before
234 // generateTerrain, because generateTerrain depends on intermediate
235 // biome-related noises.
236 m_bgen->calcBiomeNoise(node_min);
238 // Generate noise maps and base terrain height.
239 // Modify heat and humidity maps.
242 // Generate base terrain with initial heightmaps
243 s16 stone_surface_max_y = generateTerrain();
245 // Recalculate heightmap
246 updateHeightmap(node_min, node_max);
248 // Place biome-specific nodes and build biomemap
249 MgStoneType stone_type = generateBiomes();
252 if (flags & MG_CAVES)
253 generateCaves(stone_surface_max_y, large_cave_depth);
256 if ((flags & MG_DUNGEONS) && node_max.Y < 50)
257 generateDungeons(stone_surface_max_y, stone_type);
259 // Generate the registered decorations
260 if (flags & MG_DECORATIONS)
261 m_emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
263 // Generate the registered ores
264 m_emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
266 // Sprinkle some dust on top after everything else was generated
269 //TimeTaker tll("liquid_lighting");
271 updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);
273 if (flags & MG_LIGHT)
275 node_min - v3s16(0, 1, 0),
276 node_max + v3s16(0, 1, 0),
280 //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f);
281 //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f);
283 this->generating = false;
287 // Populate the noise tables and do most of the
288 // calculation necessary to determine terrain height.
289 void MapgenValleys::calculateNoise()
291 //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
294 int y = node_min.Y - 1;
297 //TimeTaker tcn("actualNoise");
299 noise_inter_valley_slope->perlinMap2D(x, z);
300 noise_rivers->perlinMap2D(x, z);
301 noise_terrain_height->perlinMap2D(x, z);
302 noise_valley_depth->perlinMap2D(x, z);
303 noise_valley_profile->perlinMap2D(x, z);
305 noise_inter_valley_fill->perlinMap3D(x, y, z);
307 //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
309 float heat_offset = 0.f;
310 float humidity_scale = 1.f;
312 // Altitude chill tends to reduce the average heat.
313 if (use_altitude_chill)
316 // River humidity tends to increase the humidity range.
318 humidity_scale = 0.8f;
321 for (s32 index = 0; index < csize.X * csize.Z; index++) {
322 m_bgen->heatmap[index] += heat_offset;
323 m_bgen->humidmap[index] *= humidity_scale;
329 for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++)
330 for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) {
331 // The parameters that we actually need to generate terrain
332 // are passed by address (and the return value).
333 tn.terrain_height = noise_terrain_height->result[index];
334 // River noise is replaced with base terrain, which
335 // is basically the height of the water table.
336 tn.rivers = &noise_rivers->result[index];
337 // Valley depth noise is replaced with the valley
338 // number that represents the height of terrain
339 // over rivers and is used to determine about
340 // how close a river is for humidity calculation.
341 tn.valley = &noise_valley_depth->result[index];
342 tn.valley_profile = noise_valley_profile->result[index];
343 // Slope noise is replaced by the calculated slope
344 // which is used to get terrain height in the slow
345 // method, to create sharper mountains.
346 tn.slope = &noise_inter_valley_slope->result[index];
347 tn.inter_valley_fill = noise_inter_valley_fill->result[index];
349 // This is the actual terrain height.
350 float mount = terrainLevelFromNoise(&tn);
351 noise_terrain_height->result[index] = mount;
356 // This keeps us from having to maintain two similar sets of
357 // complicated code to determine ground level.
358 float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
360 // The square function changes the behaviour of this noise:
361 // very often small, and sometimes very high.
362 float valley_d = MYSQUARE(*tn->valley);
364 // valley_d is here because terrain is generally higher where valleys
365 // are deep (mountains). base represents the height of the
366 // rivers, most of the surface is above.
367 float base = tn->terrain_height + valley_d;
369 // "river" represents the distance from the river, in arbitrary units.
370 float river = fabs(*tn->rivers) - river_size_factor;
372 // Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
373 // Making "a" vary (0 < a <= 1) changes the shape of the valleys.
374 // Try it with a geometry software !
375 // (here x = "river" and a = valley_profile).
376 // "valley" represents the height of the terrain, from the rivers.
378 float t = river / tn->valley_profile;
379 *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t)));
382 // approximate height of the terrain at this point
383 float mount = base + *tn->valley;
385 *tn->slope *= *tn->valley;
387 // Rivers are placed where "river" is negative, so where the original
388 // noise value is close to zero.
389 // Base ground is returned as rivers since it's basically the water table.
392 // Use the the function -sqrt(1-x^2) which models a circle.
395 float t = river / river_size_factor + 1;
396 depth = (river_depth_bed * sqrt(MYMAX(0, 1.f - MYSQUARE(t))));
399 // base - depth : height of the bottom of the river
400 // water_level - 3 : don't make rivers below 3 nodes under the surface
401 // We use three because that's as low as the swamp biomes go.
402 // There is no logical equivalent to this using rangelim.
403 mount = MYMIN(MYMAX(base - depth, (float)(water_level - 3)), mount);
405 // Slope has no influence on rivers.
413 // This avoids duplicating the code in terrainLevelFromNoise, adding
414 // only the final step of terrain generation without a noise map.
415 float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
417 float mount = terrainLevelFromNoise(tn);
418 s16 y_start = myround(mount);
420 for (s16 y = y_start; y <= y_start + 1000; y++) {
421 float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
423 if (fill * *tn->slope < y - mount) {
424 mount = MYMAX(y - 1, mount);
433 int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
435 // Check to make sure this isn't a request for a location in a river.
436 float rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
437 if (fabs(rivers) < river_size_factor)
438 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
440 s16 level_at_point = terrainLevelAtPoint(p.X, p.Y);
441 if (level_at_point <= water_level ||
442 level_at_point > water_level + 32)
443 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
445 return level_at_point;
449 float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
453 float rivers = NoisePerlin2D(&noise_rivers->np, x, z, seed);
454 float valley = NoisePerlin2D(&noise_valley_depth->np, x, z, seed);
455 float inter_valley_slope = NoisePerlin2D(&noise_inter_valley_slope->np, x, z, seed);
459 tn.terrain_height = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
462 tn.valley_profile = NoisePerlin2D(&noise_valley_profile->np, x, z, seed);
463 tn.slope = &inter_valley_slope;
464 tn.inter_valley_fill = 0.f;
466 return adjustedTerrainLevelFromNoise(&tn);
470 int MapgenValleys::generateTerrain()
472 // Raising this reduces the rate of evaporation.
473 static const float evaporation = 300.f;
475 static const float humidity_dropoff = 4.f;
476 // constant to convert altitude chill (compatible with lua) to heat
477 static const float alt_to_heat = 20.f;
478 // humidity reduction by altitude
479 static const float alt_to_humid = 10.f;
481 MapNode n_air(CONTENT_AIR);
482 MapNode n_river_water(c_river_water_source);
483 MapNode n_stone(c_stone);
484 MapNode n_water(c_water_source);
486 v3s16 em = vm->m_area.getExtent();
487 s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
490 for (s16 z = node_min.Z; z <= node_max.Z; z++)
491 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
492 float river_y = noise_rivers->result[index_2d];
493 float surface_y = noise_terrain_height->result[index_2d];
494 float slope = noise_inter_valley_slope->result[index_2d];
495 float t_heat = m_bgen->heatmap[index_2d];
497 heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
499 if (surface_y > surface_max_y)
500 surface_max_y = ceil(surface_y);
503 // Derive heat from (base) altitude. This will be most correct
504 // at rivers, since other surface heights may vary below.
505 if (use_altitude_chill && (surface_y > 0.f || river_y > 0.f))
506 t_heat -= alt_to_heat * MYMAX(surface_y, river_y) / altitude_chill;
508 // If humidity is low or heat is high, lower the water table.
509 float delta = m_bgen->humidmap[index_2d] - 50.f;
511 float t_evap = (t_heat - 32.f) / evaporation;
512 river_y += delta * MYMAX(t_evap, 0.08f);
516 u32 index_3d = (z - node_min.Z) * zstride_1u1d + (x - node_min.X);
517 u32 index_data = vm->m_area.index(x, node_min.Y - 1, z);
519 // Mapgens concern themselves with stone and water.
520 for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
521 if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
522 float fill = noise_inter_valley_fill->result[index_3d];
523 float surface_delta = (float)y - surface_y;
524 bool river = y + 1 < river_y;
526 if (slope * fill > surface_delta) {
528 vm->m_data[index_data] = n_stone;
529 if (y > heightmap[index_2d])
530 heightmap[index_2d] = y;
531 if (y > surface_max_y)
533 } else if (y <= water_level) {
535 vm->m_data[index_data] = n_water;
538 vm->m_data[index_data] = n_river_water;
540 vm->m_data[index_data] = n_air;
544 vm->m_area.add_y(em, index_data, 1);
548 if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
549 s16 surface_y_int = myround(surface_y);
550 if (surface_y_int > node_max.Y + 1 || surface_y_int < node_min.Y - 1) {
551 // If surface_y is outside the chunk, it's good enough.
552 heightmap[index_2d] = surface_y_int;
554 // If the ground is outside of this chunk, but surface_y
555 // is within the chunk, give a value outside.
556 heightmap[index_2d] = node_min.Y - 2;
561 // Use base ground (water table) in a riverbed, to
562 // avoid an unnatural rise in humidity.
563 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
564 float humid = m_bgen->humidmap[index_2d];
565 float water_depth = (t_alt - river_y) / humidity_dropoff;
566 humid *= 1.f + pow(0.5f, MYMAX(water_depth, 1.f));
568 // Reduce humidity with altitude (ignoring riverbeds).
569 // This is similar to the lua version's seawater adjustment,
570 // but doesn't increase the base humidity, which causes
571 // problems with the default biomes.
573 humid -= alt_to_humid * t_alt / altitude_chill;
575 m_bgen->humidmap[index_2d] = humid;
578 // Assign the heat adjusted by any changed altitudes.
579 // The altitude will change about half the time.
580 if (use_altitude_chill) {
581 // ground height ignoring riverbeds
582 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
583 if (humid_rivers && heightmap[index_2d] == (s16)myround(surface_y))
584 // The altitude hasn't changed. Use the first result.
585 m_bgen->heatmap[index_2d] = t_heat;
586 else if (t_alt > 0.f)
587 m_bgen->heatmap[index_2d] -= alt_to_heat * t_alt / altitude_chill;
591 return surface_max_y;
594 void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth)
596 if (max_stone_y < node_min.Y)
599 noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
600 noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
602 PseudoRandom ps(blockseed + 72202);
604 MapNode n_air(CONTENT_AIR);
605 MapNode n_lava(c_lava_source);
606 MapNode n_water(c_river_water_source);
608 v3s16 em = vm->m_area.getExtent();
610 // Cave blend distance near YMIN, YMAX
611 const float massive_cave_blend = 128.f;
612 // noise threshold for massive caves
613 const float massive_cave_threshold = 0.6f;
614 // mct: 1 = small rare caves, 0.5 1/3rd ground volume, 0 = 1/2 ground volume.
616 float yblmin = -mapgen_limit + massive_cave_blend * 1.5f;
617 float yblmax = massive_cave_depth - massive_cave_blend * 1.5f;
618 bool made_a_big_one = false;
620 // Cache the tcave values as they only vary by altitude.
621 if (node_max.Y <= massive_cave_depth) {
622 noise_massive_caves->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
624 for (s16 y = node_min.Y - 1; y <= node_max.Y; y++) {
625 float tcave = massive_cave_threshold;
628 float t = (yblmin - y) / massive_cave_blend;
629 tcave += MYSQUARE(t);
630 } else if (y > yblmax) {
631 float t = (y - yblmax) / massive_cave_blend;
632 tcave += MYSQUARE(t);
635 tcave_cache[y - node_min.Y + 1] = tcave;
639 // lava_depth varies between one and ten as you approach
640 // the bottom of the world.
641 s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / mapgen_limit);
642 // This allows random lava spawns to be less common at the surface.
643 s16 lava_chance = MYCUBE(lava_features_lim) * lava_depth;
644 // water_depth varies between ten and one on the way down.
645 s16 water_depth = ceil((mapgen_limit - abs(node_min.Y) + 1) * 10.f / mapgen_limit);
646 // This allows random water spawns to be more common at the surface.
647 s16 water_chance = MYCUBE(water_features_lim) * water_depth;
649 // Reduce the odds of overflows even further.
650 if (node_max.Y > water_level) {
656 for (s16 z = node_min.Z; z <= node_max.Z; z++)
657 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
658 Biome *biome = (Biome *)m_bmgr->getRaw(biomemap[index_2d]);
659 bool tunnel_air_above = false;
660 bool is_under_river = false;
661 bool underground = false;
662 u32 index_data = vm->m_area.index(x, node_max.Y, z);
663 u32 index_3d = (z - node_min.Z) * zstride_1d + csize.Y * ystride + (x - node_min.X);
665 // Dig caves on down loop to check for air above.
666 // Don't excavate the overgenerated stone at node_max.Y + 1,
667 // this creates a 'roof' over the tunnel, preventing light in
668 // tunnels at mapchunk borders when generating mapchunks upwards.
669 // This 'roof' is removed when the mapchunk above is generated.
670 for (s16 y = node_max.Y; y >= node_min.Y - 1; y--,
672 vm->m_area.add_y(em, index_data, -1)) {
674 float terrain = noise_terrain_height->result[index_2d];
677 if (y > terrain + 10)
679 else if (y < terrain - 40)
682 // Dig massive caves.
683 if (node_max.Y <= massive_cave_depth
684 && noise_massive_caves->result[index_3d]
685 > tcave_cache[y - node_min.Y + 1]) {
686 vm->m_data[index_data] = n_air;
687 made_a_big_one = true;
691 content_t c = vm->m_data[index_data].getContent();
692 // Detect river water to place riverbed nodes in tunnels
693 if (c == biome->c_river_water)
694 is_under_river = true;
696 float d1 = contour(noise_cave1->result[index_3d]);
697 float d2 = contour(noise_cave2->result[index_3d]);
699 if (d1 * d2 > cave_width && ndef->get(c).is_ground_content) {
701 vm->m_data[index_data] = n_air;
702 tunnel_air_above = true;
703 } else if (c == biome->c_filler || c == biome->c_stone) {
704 if (tunnel_air_above) {
705 // at the tunnel floor
706 s16 sr = ps.range(0, 39);
708 vm->m_area.add_y(em, j, 1);
710 if (sr > terrain - y) {
711 // Put biome nodes in tunnels near the surface
713 vm->m_data[index_data] = MapNode(biome->c_riverbed);
714 else if (underground)
715 vm->m_data[index_data] = MapNode(biome->c_filler);
717 vm->m_data[index_data] = MapNode(biome->c_top);
718 } else if (sr < 3 && underground) {
720 if (lava_features_lim > 0 && y <= lava_max_height
721 && c == biome->c_stone && sr < lava_chance)
722 vm->m_data[j] = n_lava;
726 // If sr < 0 then we should have already placed lava --
727 // don't immediately dump water on it.
728 if (water_features_lim > 0 && y <= cave_water_max_height
729 && sr >= 0 && sr < water_chance)
730 vm->m_data[j] = n_water;
734 tunnel_air_above = false;
737 tunnel_air_above = false;
742 if (node_max.Y <= large_cave_depth && !made_a_big_one) {
743 u32 bruises_count = ps.range(0, 2);
744 for (u32 i = 0; i < bruises_count; i++) {
745 CavesRandomWalk cave(ndef, &gennotify, seed, water_level,
746 c_water_source, c_lava_source);
748 cave.makeCave(vm, node_min, node_max, &ps, true, max_stone_y, heightmap);