src/mapgen_valleys.cpp

   1 /*
   2 Minetest Valleys C
   3 Copyright (C) 2016-2017 Duane Robertson <duane@duanerobertson.com>
   4 Copyright (C) 2016-2017 paramat
   5
   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.
   9
  10 Licensing changed by permission of Gael de Sailly.
  11
  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.
  16
  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.
  21
  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.
  25 */
  26
  27 #include "mapgen.h"
  28 #include "voxel.h"
  29 #include "noise.h"
  30 #include "mapblock.h"
  31 #include "mapnode.h"
  32 #include "map.h"
  33 #include "content_sao.h"
  34 #include "nodedef.h"
  35 #include "voxelalgorithms.h"
  36 #include "settings.h" // For g_settings
  37 #include "emerge.h"
  38 #include "dungeongen.h"
  39 #include "mg_biome.h"
  40 #include "mg_ore.h"
  41 #include "mg_decoration.h"
  42 #include "mapgen_valleys.h"
  43 #include "cavegen.h"
  44
  45
  46 //#undef NDEBUG
  47 //#include "assert.h"
  48
  49 //#include "util/timetaker.h"
  50 //#include "profiler.h"
  51
  52
  53 //static Profiler mapgen_prof;
  54 //Profiler *mapgen_profiler = &mapgen_prof;
  55
  56 static FlagDesc flagdesc_mapgen_valleys[] = {
  57         {"altitude_chill", MGVALLEYS_ALT_CHILL},
  58         {"humid_rivers",   MGVALLEYS_HUMID_RIVERS},
  59         {NULL,             0}
  60 };
  61
  62 ///////////////////////////////////////////////////////////////////////////////
  63
  64
  65 MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeManager *emerge)
  66         : MapgenBasic(mapgenid, params, emerge)
  67 {
  68         // NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal
  69         m_bgen = (BiomeGenOriginal *)biomegen;
  70
  71         BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
  72
  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
  83         //// 2D Terrain noise
  84         noise_filler_depth       = new Noise(&params->np_filler_depth,       seed, csize.X, csize.Z);
  85         noise_inter_valley_slope = new Noise(&params->np_inter_valley_slope, seed, csize.X, csize.Z);
  86         noise_rivers             = new Noise(&params->np_rivers,             seed, csize.X, csize.Z);
  87         noise_terrain_height     = new Noise(&params->np_terrain_height,     seed, csize.X, csize.Z);
  88         noise_valley_depth       = new Noise(&params->np_valley_depth,       seed, csize.X, csize.Z);
  89         noise_valley_profile     = new Noise(&params->np_valley_profile,     seed, csize.X, csize.Z);
  90
  91         //// 3D Terrain noise
  92         // 1-up 1-down overgeneration
  93         noise_inter_valley_fill = new Noise(&params->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
  94         // 1-down overgeneraion
  95         noise_cave1             = new Noise(&params->np_cave1,             seed, csize.X, csize.Y + 1, csize.Z);
  96         noise_cave2             = new Noise(&params->np_cave2,             seed, csize.X, csize.Y + 1, csize.Z);
  97         noise_massive_caves     = new Noise(&params->np_massive_caves,     seed, csize.X, csize.Y + 1, csize.Z);
  98
  99         humid_rivers       = (spflags & MGVALLEYS_HUMID_RIVERS);
 100         use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
 101         humidity_adjust    = bp->np_humidity.offset - 50.f;
 102
 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;
 106
 107         tcave_cache = new float[csize.Y + 2];
 108 }
 109
 110
 111 MapgenValleys::~MapgenValleys()
 112 {
 113         delete noise_cave1;
 114         delete noise_cave2;
 115         delete noise_filler_depth;
 116         delete noise_inter_valley_fill;
 117         delete noise_inter_valley_slope;
 118         delete noise_rivers;
 119         delete noise_massive_caves;
 120         delete noise_terrain_height;
 121         delete noise_valley_depth;
 122         delete noise_valley_profile;
 123
 124         delete[] tcave_cache;
 125 }
 126
 127
 128 MapgenValleysParams::MapgenValleysParams()
 129 {
 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);
 140 }
 141
 142
 143 void MapgenValleysParams::readParams(const Settings *settings)
 144 {
 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);
 154
 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);
 165 }
 166
 167
 168 void MapgenValleysParams::writeParams(Settings *settings) const
 169 {
 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);
 179
 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);
 190 }
 191
 192
 193 ///////////////////////////////////////
 194
 195
 196 void MapgenValleys::makeChunk(BlockMakeData *data)
 197 {
 198         // Pre-conditions
 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);
 207
 208         this->generating = true;
 209         this->vm = data->vmanip;
 210         this->ndef = data->nodedef;
 211
 212         //TimeTaker t("makeChunk");
 213
 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);
 220
 221         blockseed = getBlockSeed2(full_node_min, seed);
 222
 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);
 227
 228         // Generate noise maps and base terrain height.
 229         // Modify heat and humidity maps.
 230         calculateNoise();
 231
 232         // Generate base terrain with initial heightmaps
 233         s16 stone_surface_max_y = generateTerrain();
 234
 235         // Recalculate heightmap
 236         updateHeightmap(node_min, node_max);
 237
 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);
 242
 243         // Cave creation.
 244         if (flags & MG_CAVES)
 245                 generateCaves(stone_surface_max_y, large_cave_depth);
 246
 247         // Dungeon creation
 248         if ((flags & MG_DUNGEONS) && node_max.Y < 50)
 249                 generateDungeons(stone_surface_max_y, mgstone_type, biome_stone);
 250
 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);
 255
 256         // Generate the registered ores
 257         m_emerge->oremgr->placeAllOres(this, blockseed,
 258                 node_min, node_max, water_level - 1);
 259
 260         // Sprinkle some dust on top after everything else was generated
 261         dustTopNodes();
 262
 263         //TimeTaker tll("liquid_lighting");
 264
 265         updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);
 266
 267         if (flags & MG_LIGHT)
 268                 calcLighting(
 269                                 node_min - v3s16(0, 1, 0),
 270                                 node_max + v3s16(0, 1, 0),
 271                                 full_node_min,
 272                                 full_node_max);
 273
 274         //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f);
 275         //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f);
 276
 277         this->generating = false;
 278 }
 279
 280
 281 // Populate the noise tables and do most of the
 282 // calculation necessary to determine terrain height.
 283 void MapgenValleys::calculateNoise()
 284 {
 285         //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
 286
 287         int x = node_min.X;
 288         int y = node_min.Y - 1;
 289         int z = node_min.Z;
 290
 291         //TimeTaker tcn("actualNoise");
 292
 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);
 298
 299         noise_inter_valley_fill->perlinMap3D(x, y, z);
 300
 301         //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
 302
 303         float heat_offset = 0.f;
 304         float humidity_scale = 1.f;
 305
 306         // Altitude chill tends to reduce the average heat.
 307         if (use_altitude_chill)
 308                 heat_offset = 5.f;
 309
 310         // River humidity tends to increase the humidity range.
 311         if (humid_rivers) {
 312                 humidity_scale = 0.8f;
 313         }
 314
 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;
 318         }
 319
 320         TerrainNoise tn;
 321
 322         u32 index = 0;
 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];
 342
 343                 // This is the actual terrain height.
 344                 float mount = terrainLevelFromNoise(&tn);
 345                 noise_terrain_height->result[index] = mount;
 346         }
 347 }
 348
 349
 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)
 353 {
 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);
 357
 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;
 362
 363         // "river" represents the distance from the river, in arbitrary units.
 364         float river = fabs(*tn->rivers) - river_size_factor;
 365
 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.
 371         {
 372                 float t = river / tn->valley_profile;
 373                 *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t)));
 374         }
 375
 376         // approximate height of the terrain at this point
 377         float mount = base + *tn->valley;
 378
 379         *tn->slope *= *tn->valley;
 380
 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.
 384         *tn->rivers = base;
 385         if (river < 0.f) {
 386                 // Use the the function -sqrt(1-x^2) which models a circle.
 387                 float depth;
 388                 {
 389                         float t = river / river_size_factor + 1;
 390                         depth = (river_depth_bed * sqrt(MYMAX(0, 1.f - MYSQUARE(t))));
 391                 }
 392
 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);
 398
 399                 // Slope has no influence on rivers.
 400                 *tn->slope = 0.f;
 401         }
 402
 403         return mount;
 404 }
 405
 406
 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)
 410 {
 411         float mount = terrainLevelFromNoise(tn);
 412         s16 y_start = myround(mount);
 413
 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);
 416
 417                 if (fill * *tn->slope < y - mount) {
 418                         mount = MYMAX(y - 1, mount);
 419                         break;
 420                 }
 421         }
 422
 423         return mount;
 424 }
 425
 426
 427 int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
 428 {
 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
 433
 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
 438         else
 439                 return level_at_point;
 440 }
 441
 442
 443 float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
 444 {
 445         TerrainNoise tn;
 446
 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);
 450
 451         tn.x                 = x;
 452         tn.z                 = z;
 453         tn.terrain_height    = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
 454         tn.rivers            = &rivers;
 455         tn.valley            = &valley;
 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;
 459
 460         return adjustedTerrainLevelFromNoise(&tn);
 461 }
 462
 463
 464 int MapgenValleys::generateTerrain()
 465 {
 466         // Raising this reduces the rate of evaporation.
 467         static const float evaporation = 300.f;
 468         // from the lua
 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;
 474
 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);
 479
 480         const v3s16 &em = vm->m_area.getExtent();
 481         s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
 482         u32 index_2d = 0;
 483
 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];
 490
 491                 heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
 492
 493                 if (surface_y > surface_max_y)
 494                         surface_max_y = ceil(surface_y);
 495
 496                 if (humid_rivers) {
 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;
 501
 502                         // If humidity is low or heat is high, lower the water table.
 503                         float delta = m_bgen->humidmap[index_2d] - 50.f;
 504                         if (delta < 0.f) {
 505                                 float t_evap = (t_heat - 32.f) / evaporation;
 506                                 river_y += delta * MYMAX(t_evap, 0.08f);
 507                         }
 508                 }
 509
 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);
 512
 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;
 519
 520                                 if (slope * fill > surface_delta) {
 521                                         // ground
 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)
 526                                                 surface_max_y = y;
 527                                 } else if (y <= water_level) {
 528                                         // sea
 529                                         vm->m_data[index_data] = n_water;
 530                                 } else if (river) {
 531                                         // river
 532                                         vm->m_data[index_data] = n_river_water;
 533                                 } else {  // air
 534                                         vm->m_data[index_data] = n_air;
 535                                 }
 536                         }
 537
 538                         vm->m_area.add_y(em, index_data, 1);
 539                         index_3d += ystride;
 540                 }
 541
 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;
 547                         } else {
 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;
 551                         }
 552                 }
 553
 554                 if (humid_rivers) {
 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));
 561
 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.
 566                         if (t_alt > 0.f)
 567                                 humid -= alt_to_humid * t_alt / altitude_chill;
 568
 569                         m_bgen->humidmap[index_2d] = humid;
 570                 }
 571
 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;
 582                 }
 583         }
 584
 585         return surface_max_y;
 586 }
 587
 588 void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth)
 589 {
 590         if (max_stone_y < node_min.Y)
 591                 return;
 592
 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);
 595
 596         PseudoRandom ps(blockseed + 72202);
 597
 598         MapNode n_air(CONTENT_AIR);
 599         MapNode n_lava(c_lava_source);
 600         MapNode n_water(c_river_water_source);
 601
 602         const v3s16 &em = vm->m_area.getExtent();
 603
 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.
 609
 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;
 613
 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);
 617
 618                 for (s16 y = node_min.Y - 1; y <= node_max.Y; y++) {
 619                         float tcave = massive_cave_threshold;
 620
 621                         if (y < yblmin) {
 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);
 627                         }
 628
 629                         tcave_cache[y - node_min.Y + 1] = tcave;
 630                 }
 631         }
 632
 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;
 642
 643         // Reduce the odds of overflows even further.
 644         if (node_max.Y > water_level) {
 645                 lava_chance /= 3;
 646                 water_chance /= 3;
 647         }
 648
 649         u32 index_2d = 0;
 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);
 658
 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--,
 665                                 index_3d -= ystride,
 666                                 vm->m_area.add_y(em, index_data, -1)) {
 667
 668                         float terrain = noise_terrain_height->result[index_2d];
 669
 670                         // Saves some time.
 671                         if (y > terrain + 10)
 672                                 continue;
 673                         else if (y < terrain - 40)
 674                                 underground = true;
 675
 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;
 682                                 continue;
 683                         }
 684
 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;
 689
 690                         float d1 = contour(noise_cave1->result[index_3d]);
 691                         float d2 = contour(noise_cave2->result[index_3d]);
 692
 693                         if (d1 * d2 > cave_width && ndef->get(c).is_ground_content) {
 694                                 // in a tunnel
 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);
 701                                         u32 j = index_data;
 702                                         vm->m_area.add_y(em, j, 1);
 703
 704                                         if (sr > terrain - y) {
 705                                                 // Put biome nodes in tunnels near the surface
 706                                                 if (is_under_river)
 707                                                         vm->m_data[index_data] = MapNode(biome->c_riverbed);
 708                                                 else if (underground)
 709                                                         vm->m_data[index_data] = MapNode(biome->c_filler);
 710                                                 else
 711                                                         vm->m_data[index_data] = MapNode(biome->c_top);
 712                                         } else if (sr < 3 && underground) {
 713                                                 sr = abs(ps.next());
 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;
 717
 718                                                 sr -= lava_chance;
 719
 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;
 725                                         }
 726                                 }
 727
 728                                 tunnel_air_above = false;
 729                                 underground = true;
 730                         } else {
 731                                 tunnel_air_above = false;
 732                         }
 733                 }
 734         }
 735
 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);
 741
 742                         cave.makeCave(vm, node_min, node_max, &ps, true, max_stone_y, heightmap);
 743                 }
 744         }
 745 }