3 Copyright (C) 2016-2018 Duane Robertson <duane@duanerobertson.com>
4 Copyright (C) 2016-2018 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.
34 #include "voxelalgorithms.h"
35 #include "settings.h" // For g_settings
37 #include "dungeongen.h"
40 #include "mg_decoration.h"
41 #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;
82 dungeon_ymin = params->dungeon_ymin;
83 dungeon_ymax = params->dungeon_ymax;
86 noise_filler_depth = new Noise(¶ms->np_filler_depth, seed, csize.X, csize.Z);
87 noise_inter_valley_slope = new Noise(¶ms->np_inter_valley_slope, seed, csize.X, csize.Z);
88 noise_rivers = new Noise(¶ms->np_rivers, seed, csize.X, csize.Z);
89 noise_terrain_height = new Noise(¶ms->np_terrain_height, seed, csize.X, csize.Z);
90 noise_valley_depth = new Noise(¶ms->np_valley_depth, seed, csize.X, csize.Z);
91 noise_valley_profile = new Noise(¶ms->np_valley_profile, seed, csize.X, csize.Z);
94 // 1-up 1-down overgeneration
95 noise_inter_valley_fill = new Noise(¶ms->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
96 // 1-down overgeneraion
97 noise_cave1 = new Noise(¶ms->np_cave1, seed, csize.X, csize.Y + 1, csize.Z);
98 noise_cave2 = new Noise(¶ms->np_cave2, seed, csize.X, csize.Y + 1, csize.Z);
99 noise_massive_caves = new Noise(¶ms->np_massive_caves, seed, csize.X, csize.Y + 1, csize.Z);
101 humid_rivers = (spflags & MGVALLEYS_HUMID_RIVERS);
102 use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
103 humidity_adjust = bp->np_humidity.offset - 50.f;
105 // a small chance of overflows if the settings are very high
106 cave_water_max_height = water_level + MYMAX(0, water_features_lim - 4) * 50;
107 lava_max_height = water_level + MYMAX(0, lava_features_lim - 4) * 50;
109 tcave_cache = new float[csize.Y + 2];
113 MapgenValleys::~MapgenValleys()
117 delete noise_filler_depth;
118 delete noise_inter_valley_fill;
119 delete noise_inter_valley_slope;
121 delete noise_massive_caves;
122 delete noise_terrain_height;
123 delete noise_valley_depth;
124 delete noise_valley_profile;
126 delete[] tcave_cache;
130 MapgenValleysParams::MapgenValleysParams():
131 np_cave1 (0, 12, v3f(61, 61, 61), 52534, 3, 0.5, 2.0),
132 np_cave2 (0, 12, v3f(67, 67, 67), 10325, 3, 0.5, 2.0),
133 np_filler_depth (0.f, 1.2f, v3f(256, 256, 256), 1605, 3, 0.5f, 2.f),
134 np_inter_valley_fill (0.f, 1.f, v3f(256, 512, 256), 1993, 6, 0.8f, 2.f),
135 np_inter_valley_slope (0.5f, 0.5f, v3f(128, 128, 128), 746, 1, 1.f, 2.f),
136 np_rivers (0.f, 1.f, v3f(256, 256, 256), -6050, 5, 0.6f, 2.f),
137 np_massive_caves (0.f, 1.f, v3f(768, 256, 768), 59033, 6, 0.63f, 2.f),
138 np_terrain_height (-10.f, 50.f, v3f(1024, 1024, 1024), 5202, 6, 0.4f, 2.f),
139 np_valley_depth (5.f, 4.f, v3f(512, 512, 512), -1914, 1, 1.f, 2.f),
140 np_valley_profile (0.6f, 0.5f, v3f(512, 512, 512), 777, 1, 1.f, 2.f)
145 void MapgenValleysParams::readParams(const Settings *settings)
147 settings->getFlagStrNoEx("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys);
148 settings->getU16NoEx("mgvalleys_altitude_chill", altitude_chill);
149 settings->getS16NoEx("mgvalleys_large_cave_depth", large_cave_depth);
150 settings->getU16NoEx("mgvalleys_lava_features", lava_features);
151 settings->getS16NoEx("mgvalleys_massive_cave_depth", massive_cave_depth);
152 settings->getU16NoEx("mgvalleys_river_depth", river_depth);
153 settings->getU16NoEx("mgvalleys_river_size", river_size);
154 settings->getU16NoEx("mgvalleys_water_features", water_features);
155 settings->getFloatNoEx("mgvalleys_cave_width", cave_width);
156 settings->getS16NoEx("mgvalleys_dungeon_ymin", dungeon_ymin);
157 settings->getS16NoEx("mgvalleys_dungeon_ymax", dungeon_ymax);
159 settings->getNoiseParams("mgvalleys_np_cave1", np_cave1);
160 settings->getNoiseParams("mgvalleys_np_cave2", np_cave2);
161 settings->getNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
162 settings->getNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
163 settings->getNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
164 settings->getNoiseParams("mgvalleys_np_rivers", np_rivers);
165 settings->getNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
166 settings->getNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
167 settings->getNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
168 settings->getNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
172 void MapgenValleysParams::writeParams(Settings *settings) const
174 settings->setFlagStr("mgvalleys_spflags", spflags, flagdesc_mapgen_valleys, U32_MAX);
175 settings->setU16("mgvalleys_altitude_chill", altitude_chill);
176 settings->setS16("mgvalleys_large_cave_depth", large_cave_depth);
177 settings->setU16("mgvalleys_lava_features", lava_features);
178 settings->setS16("mgvalleys_massive_cave_depth", massive_cave_depth);
179 settings->setU16("mgvalleys_river_depth", river_depth);
180 settings->setU16("mgvalleys_river_size", river_size);
181 settings->setU16("mgvalleys_water_features", water_features);
182 settings->setFloat("mgvalleys_cave_width", cave_width);
183 settings->setS16("mgvalleys_dungeon_ymin", dungeon_ymin);
184 settings->setS16("mgvalleys_dungeon_ymax", dungeon_ymax);
186 settings->setNoiseParams("mgvalleys_np_cave1", np_cave1);
187 settings->setNoiseParams("mgvalleys_np_cave2", np_cave2);
188 settings->setNoiseParams("mgvalleys_np_filler_depth", np_filler_depth);
189 settings->setNoiseParams("mgvalleys_np_inter_valley_fill", np_inter_valley_fill);
190 settings->setNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
191 settings->setNoiseParams("mgvalleys_np_rivers", np_rivers);
192 settings->setNoiseParams("mgvalleys_np_massive_caves", np_massive_caves);
193 settings->setNoiseParams("mgvalleys_np_terrain_height", np_terrain_height);
194 settings->setNoiseParams("mgvalleys_np_valley_depth", np_valley_depth);
195 settings->setNoiseParams("mgvalleys_np_valley_profile", np_valley_profile);
199 ///////////////////////////////////////
202 void MapgenValleys::makeChunk(BlockMakeData *data)
205 assert(data->vmanip);
206 assert(data->nodedef);
207 assert(data->blockpos_requested.X >= data->blockpos_min.X &&
208 data->blockpos_requested.Y >= data->blockpos_min.Y &&
209 data->blockpos_requested.Z >= data->blockpos_min.Z);
210 assert(data->blockpos_requested.X <= data->blockpos_max.X &&
211 data->blockpos_requested.Y <= data->blockpos_max.Y &&
212 data->blockpos_requested.Z <= data->blockpos_max.Z);
214 this->generating = true;
215 this->vm = data->vmanip;
216 this->ndef = data->nodedef;
218 //TimeTaker t("makeChunk");
220 v3s16 blockpos_min = data->blockpos_min;
221 v3s16 blockpos_max = data->blockpos_max;
222 node_min = blockpos_min * MAP_BLOCKSIZE;
223 node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
224 full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
225 full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
227 blockseed = getBlockSeed2(full_node_min, seed);
229 // Generate biome noises. Note this must be executed strictly before
230 // generateTerrain, because generateTerrain depends on intermediate
231 // biome-related noises.
232 m_bgen->calcBiomeNoise(node_min);
234 // Generate noise maps and base terrain height.
235 // Modify heat and humidity maps.
238 // Generate base terrain with initial heightmaps
239 s16 stone_surface_max_y = generateTerrain();
241 // Recalculate heightmap
242 updateHeightmap(node_min, node_max);
244 // Place biome-specific nodes and build biomemap
245 MgStoneType mgstone_type;
246 content_t biome_stone;
247 generateBiomes(&mgstone_type, &biome_stone);
250 if (flags & MG_CAVES)
251 generateCaves(stone_surface_max_y, large_cave_depth);
254 if ((flags & MG_DUNGEONS) && full_node_min.Y >= dungeon_ymin &&
255 full_node_max.Y <= dungeon_ymax)
256 generateDungeons(stone_surface_max_y, mgstone_type, biome_stone);
258 // Generate the registered decorations
259 if (flags & MG_DECORATIONS)
260 m_emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
262 // Generate the registered ores
263 m_emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
265 // Sprinkle some dust on top after everything else was generated
268 //TimeTaker tll("liquid_lighting");
270 updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);
272 if (flags & MG_LIGHT)
274 node_min - v3s16(0, 1, 0),
275 node_max + v3s16(0, 1, 0),
279 //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f);
280 //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f);
282 this->generating = false;
286 // Populate the noise tables and do most of the
287 // calculation necessary to determine terrain height.
288 void MapgenValleys::calculateNoise()
290 //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
293 int y = node_min.Y - 1;
296 //TimeTaker tcn("actualNoise");
298 noise_inter_valley_slope->perlinMap2D(x, z);
299 noise_rivers->perlinMap2D(x, z);
300 noise_terrain_height->perlinMap2D(x, z);
301 noise_valley_depth->perlinMap2D(x, z);
302 noise_valley_profile->perlinMap2D(x, z);
304 noise_inter_valley_fill->perlinMap3D(x, y, z);
306 //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
308 float heat_offset = 0.f;
309 float humidity_scale = 1.f;
311 // Altitude chill tends to reduce the average heat.
312 if (use_altitude_chill)
315 // River humidity tends to increase the humidity range.
317 humidity_scale = 0.8f;
320 for (s32 index = 0; index < csize.X * csize.Z; index++) {
321 m_bgen->heatmap[index] += heat_offset;
322 m_bgen->humidmap[index] *= humidity_scale;
328 for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++)
329 for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) {
330 // The parameters that we actually need to generate terrain
331 // are passed by address (and the return value).
332 tn.terrain_height = noise_terrain_height->result[index];
333 // River noise is replaced with base terrain, which
334 // is basically the height of the water table.
335 tn.rivers = &noise_rivers->result[index];
336 // Valley depth noise is replaced with the valley
337 // number that represents the height of terrain
338 // over rivers and is used to determine about
339 // how close a river is for humidity calculation.
340 tn.valley = &noise_valley_depth->result[index];
341 tn.valley_profile = noise_valley_profile->result[index];
342 // Slope noise is replaced by the calculated slope
343 // which is used to get terrain height in the slow
344 // method, to create sharper mountains.
345 tn.slope = &noise_inter_valley_slope->result[index];
346 tn.inter_valley_fill = noise_inter_valley_fill->result[index];
348 // This is the actual terrain height.
349 float mount = terrainLevelFromNoise(&tn);
350 noise_terrain_height->result[index] = mount;
355 // This keeps us from having to maintain two similar sets of
356 // complicated code to determine ground level.
357 float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
359 // The square function changes the behaviour of this noise:
360 // very often small, and sometimes very high.
361 float valley_d = MYSQUARE(*tn->valley);
363 // valley_d is here because terrain is generally higher where valleys
364 // are deep (mountains). base represents the height of the
365 // rivers, most of the surface is above.
366 float base = tn->terrain_height + valley_d;
368 // "river" represents the distance from the river, in arbitrary units.
369 float river = fabs(*tn->rivers) - river_size_factor;
371 // Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
372 // Making "a" vary (0 < a <= 1) changes the shape of the valleys.
373 // Try it with a geometry software !
374 // (here x = "river" and a = valley_profile).
375 // "valley" represents the height of the terrain, from the rivers.
377 float t = std::fmax(river / tn->valley_profile, 0.0f);
378 *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t)));
381 // approximate height of the terrain at this point
382 float mount = base + *tn->valley;
384 *tn->slope *= *tn->valley;
386 // Rivers are placed where "river" is negative, so where the original
387 // noise value is close to zero.
388 // Base ground is returned as rivers since it's basically the water table.
391 // Use the the function -sqrt(1-x^2) which models a circle.
394 float t = river / river_size_factor + 1;
395 depth = (river_depth_bed * sqrt(MYMAX(0, 1.f - MYSQUARE(t))));
398 // base - depth : height of the bottom of the river
399 // water_level - 3 : don't make rivers below 3 nodes under the surface
400 // We use three because that's as low as the swamp biomes go.
401 // There is no logical equivalent to this using rangelim.
402 mount = MYMIN(MYMAX(base - depth, (float)(water_level - 3)), mount);
404 // Slope has no influence on rivers.
412 // This avoids duplicating the code in terrainLevelFromNoise, adding
413 // only the final step of terrain generation without a noise map.
414 float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
416 float mount = terrainLevelFromNoise(tn);
417 s16 y_start = myround(mount);
419 for (s16 y = y_start; y <= y_start + 1000; y++) {
420 float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
422 if (fill * *tn->slope < y - mount) {
423 mount = MYMAX(y - 1, mount);
432 int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
434 // Check to make sure this isn't a request for a location in a river.
435 float rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
436 if (fabs(rivers) < river_size_factor)
437 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
439 s16 level_at_point = terrainLevelAtPoint(p.X, p.Y);
440 if (level_at_point <= water_level ||
441 level_at_point > water_level + 32)
442 return MAX_MAP_GENERATION_LIMIT; // Unsuitable spawn point
444 return level_at_point;
448 float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
452 float rivers = NoisePerlin2D(&noise_rivers->np, x, z, seed);
453 float valley = NoisePerlin2D(&noise_valley_depth->np, x, z, seed);
454 float inter_valley_slope = NoisePerlin2D(&noise_inter_valley_slope->np, x, z, seed);
458 tn.terrain_height = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
461 tn.valley_profile = NoisePerlin2D(&noise_valley_profile->np, x, z, seed);
462 tn.slope = &inter_valley_slope;
463 tn.inter_valley_fill = 0.f;
465 return adjustedTerrainLevelFromNoise(&tn);
469 int MapgenValleys::generateTerrain()
471 // Raising this reduces the rate of evaporation.
472 static const float evaporation = 300.f;
474 static const float humidity_dropoff = 4.f;
475 // constant to convert altitude chill (compatible with lua) to heat
476 static const float alt_to_heat = 20.f;
477 // humidity reduction by altitude
478 static const float alt_to_humid = 10.f;
480 MapNode n_air(CONTENT_AIR);
481 MapNode n_river_water(c_river_water_source);
482 MapNode n_stone(c_stone);
483 MapNode n_water(c_water_source);
485 const v3s16 &em = vm->m_area.getExtent();
486 s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
489 for (s16 z = node_min.Z; z <= node_max.Z; z++)
490 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
491 float river_y = noise_rivers->result[index_2d];
492 float surface_y = noise_terrain_height->result[index_2d];
493 float slope = noise_inter_valley_slope->result[index_2d];
494 float t_heat = m_bgen->heatmap[index_2d];
496 heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
498 if (surface_y > surface_max_y)
499 surface_max_y = ceil(surface_y);
502 // Derive heat from (base) altitude. This will be most correct
503 // at rivers, since other surface heights may vary below.
504 if (use_altitude_chill && (surface_y > 0.f || river_y > 0.f))
505 t_heat -= alt_to_heat * MYMAX(surface_y, river_y) / altitude_chill;
507 // If humidity is low or heat is high, lower the water table.
508 float delta = m_bgen->humidmap[index_2d] - 50.f;
510 float t_evap = (t_heat - 32.f) / evaporation;
511 river_y += delta * MYMAX(t_evap, 0.08f);
515 u32 index_3d = (z - node_min.Z) * zstride_1u1d + (x - node_min.X);
516 u32 index_data = vm->m_area.index(x, node_min.Y - 1, z);
518 // Mapgens concern themselves with stone and water.
519 for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
520 if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
521 float fill = noise_inter_valley_fill->result[index_3d];
522 float surface_delta = (float)y - surface_y;
523 bool river = y + 1 < river_y;
525 if (slope * fill > surface_delta) {
527 vm->m_data[index_data] = n_stone;
528 if (y > heightmap[index_2d])
529 heightmap[index_2d] = y;
530 if (y > surface_max_y)
532 } else if (y <= water_level) {
534 vm->m_data[index_data] = n_water;
537 vm->m_data[index_data] = n_river_water;
539 vm->m_data[index_data] = n_air;
543 vm->m_area.add_y(em, index_data, 1);
547 if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
548 s16 surface_y_int = myround(surface_y);
549 if (surface_y_int > node_max.Y + 1 || surface_y_int < node_min.Y - 1) {
550 // If surface_y is outside the chunk, it's good enough.
551 heightmap[index_2d] = surface_y_int;
553 // If the ground is outside of this chunk, but surface_y
554 // is within the chunk, give a value outside.
555 heightmap[index_2d] = node_min.Y - 2;
560 // Use base ground (water table) in a riverbed, to
561 // avoid an unnatural rise in humidity.
562 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
563 float humid = m_bgen->humidmap[index_2d];
564 float water_depth = (t_alt - river_y) / humidity_dropoff;
565 humid *= 1.f + pow(0.5f, MYMAX(water_depth, 1.f));
567 // Reduce humidity with altitude (ignoring riverbeds).
568 // This is similar to the lua version's seawater adjustment,
569 // but doesn't increase the base humidity, which causes
570 // problems with the default biomes.
572 humid -= alt_to_humid * t_alt / altitude_chill;
574 m_bgen->humidmap[index_2d] = humid;
577 // Assign the heat adjusted by any changed altitudes.
578 // The altitude will change about half the time.
579 if (use_altitude_chill) {
580 // ground height ignoring riverbeds
581 float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
582 if (humid_rivers && heightmap[index_2d] == (s16)myround(surface_y))
583 // The altitude hasn't changed. Use the first result.
584 m_bgen->heatmap[index_2d] = t_heat;
585 else if (t_alt > 0.f)
586 m_bgen->heatmap[index_2d] -= alt_to_heat * t_alt / altitude_chill;
590 return surface_max_y;
593 void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth)
595 if (max_stone_y < node_min.Y)
598 noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
599 noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
601 PseudoRandom ps(blockseed + 72202);
603 MapNode n_air(CONTENT_AIR);
604 MapNode n_lava(c_lava_source);
605 MapNode n_water(c_river_water_source);
607 const v3s16 &em = vm->m_area.getExtent();
609 // Cave blend distance near YMIN, YMAX
610 const float massive_cave_blend = 128.f;
611 // noise threshold for massive caves
612 const float massive_cave_threshold = 0.6f;
613 // mct: 1 = small rare caves, 0.5 1/3rd ground volume, 0 = 1/2 ground volume.
615 float yblmin = -mapgen_limit + massive_cave_blend * 1.5f;
616 float yblmax = massive_cave_depth - massive_cave_blend * 1.5f;
617 bool made_a_big_one = false;
619 // Cache the tcave values as they only vary by altitude.
620 if (node_max.Y <= massive_cave_depth) {
621 noise_massive_caves->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
623 for (s16 y = node_min.Y - 1; y <= node_max.Y; y++) {
624 float tcave = massive_cave_threshold;
627 float t = (yblmin - y) / massive_cave_blend;
628 tcave += MYSQUARE(t);
629 } else if (y > yblmax) {
630 float t = (y - yblmax) / massive_cave_blend;
631 tcave += MYSQUARE(t);
634 tcave_cache[y - node_min.Y + 1] = tcave;
638 // lava_depth varies between one and ten as you approach
639 // the bottom of the world.
640 s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / mapgen_limit);
641 // This allows random lava spawns to be less common at the surface.
642 s16 lava_chance = MYCUBE(lava_features_lim) * lava_depth;
643 // water_depth varies between ten and one on the way down.
644 s16 water_depth = ceil((mapgen_limit - abs(node_min.Y) + 1) * 10.f / mapgen_limit);
645 // This allows random water spawns to be more common at the surface.
646 s16 water_chance = MYCUBE(water_features_lim) * water_depth;
648 // Reduce the odds of overflows even further.
649 if (node_max.Y > water_level) {
655 for (s16 z = node_min.Z; z <= node_max.Z; z++)
656 for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
657 Biome *biome = (Biome *)m_bmgr->getRaw(biomemap[index_2d]);
658 bool tunnel_air_above = false;
659 bool is_under_river = false;
660 bool underground = false;
661 u32 index_data = vm->m_area.index(x, node_max.Y, z);
662 u32 index_3d = (z - node_min.Z) * zstride_1d + csize.Y * ystride + (x - node_min.X);
664 // Dig caves on down loop to check for air above.
665 // Don't excavate the overgenerated stone at node_max.Y + 1,
666 // this creates a 'roof' over the tunnel, preventing light in
667 // tunnels at mapchunk borders when generating mapchunks upwards.
668 // This 'roof' is removed when the mapchunk above is generated.
669 for (s16 y = node_max.Y; y >= node_min.Y - 1; y--,
671 vm->m_area.add_y(em, index_data, -1)) {
673 float terrain = noise_terrain_height->result[index_2d];
676 if (y > terrain + 10)
679 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, lava_max_height);
748 cave.makeCave(vm, node_min, node_max, &ps, true, max_stone_y, heightmap);