src/mapgen_valleys.cpp

   1 /*
   2 Minetest Valleys C
   3 Copyright (C) 2010-2015 kwolekr, Ryan Kwolek <kwolekr@minetest.net>
   4 Copyright (C) 2010-2015 paramat, Matt Gregory
   5 Copyright (C) 2016 Duane Robertson <duane@duanerobertson.com>
   6
   7 Based on Valleys Mapgen by Gael de Sailly
   8  (https://forum.minetest.net/viewtopic.php?f=9&t=11430)
   9 and mapgen_v7, mapgen_flat by kwolekr and paramat.
  10
  11 Licensing changed by permission of Gael de Sailly.
  12
  13 This program is free software; you can redistribute it and/or modify
  14 it under the terms of the GNU Lesser General Public License as published by
  15 the Free Software Foundation; either version 2.1 of the License, or
  16 (at your option) any later version.
  17
  18 This program is distributed in the hope that it will be useful,
  19 but WITHOUT ANY WARRANTY; without even the implied warranty of
  20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21 GNU Lesser General Public License for more details.
  22
  23 You should have received a copy of the GNU Lesser General Public License along
  24 with this program; if not, write to the Free Software Foundation, Inc.,
  25 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  26 */
  27
  28 #include "mapgen.h"
  29 #include "voxel.h"
  30 #include "noise.h"
  31 #include "mapblock.h"
  32 #include "mapnode.h"
  33 #include "map.h"
  34 #include "content_sao.h"
  35 #include "nodedef.h"
  36 #include "voxelalgorithms.h"
  37 #include "settings.h" // For g_settings
  38 #include "emerge.h"
  39 #include "dungeongen.h"
  40 #include "treegen.h"
  41 #include "mg_biome.h"
  42 #include "mg_ore.h"
  43 #include "mg_decoration.h"
  44 #include "mapgen_valleys.h"
  45 #include "cavegen.h"
  46
  47
  48 //#undef NDEBUG
  49 //#include "assert.h"
  50
  51 //#include "util/timetaker.h"
  52 //#include "profiler.h"
  53
  54
  55 //static Profiler mapgen_prof;
  56 //Profiler *mapgen_profiler = &mapgen_prof;
  57
  58 static FlagDesc flagdesc_mapgen_valleys[] = {
  59         {"altitude_chill", MGVALLEYS_ALT_CHILL},
  60         {"humid_rivers",   MGVALLEYS_HUMID_RIVERS},
  61         {NULL,             0}
  62 };
  63
  64 ///////////////////////////////////////////////////////////////////////////////
  65
  66
  67 MapgenValleys::MapgenValleys(int mapgenid, MapgenValleysParams *params, EmergeManager *emerge)
  68         : MapgenBasic(mapgenid, params, emerge)
  69 {
  70         // NOTE: MapgenValleys has a hard dependency on BiomeGenOriginal
  71         this->m_bgen = (BiomeGenOriginal *)biomegen;
  72
  73         BiomeParamsOriginal *bp = (BiomeParamsOriginal *)params->bparams;
  74
  75         this->spflags            = params->spflags;
  76         this->altitude_chill     = params->altitude_chill;
  77         this->large_cave_depth   = params->large_cave_depth;
  78         this->lava_features_lim  = rangelim(params->lava_features, 0, 10);
  79         this->massive_cave_depth = params->massive_cave_depth;
  80         this->river_depth_bed    = params->river_depth + 1.f;
  81         this->river_size_factor  = params->river_size / 100.f;
  82         this->water_features_lim = rangelim(params->water_features, 0, 10);
  83         this->cave_width         = params->cave_width;
  84
  85         //// 2D Terrain noise
  86         noise_filler_depth       = new Noise(&params->np_filler_depth,       seed, csize.X, csize.Z);
  87         noise_inter_valley_slope = new Noise(&params->np_inter_valley_slope, seed, csize.X, csize.Z);
  88         noise_rivers             = new Noise(&params->np_rivers,             seed, csize.X, csize.Z);
  89         noise_terrain_height     = new Noise(&params->np_terrain_height,     seed, csize.X, csize.Z);
  90         noise_valley_depth       = new Noise(&params->np_valley_depth,       seed, csize.X, csize.Z);
  91         noise_valley_profile     = new Noise(&params->np_valley_profile,     seed, csize.X, csize.Z);
  92
  93         //// 3D Terrain noise
  94         // 1-up 1-down overgeneration
  95         noise_inter_valley_fill = new Noise(&params->np_inter_valley_fill, seed, csize.X, csize.Y + 2, csize.Z);
  96         // 1-down overgeneraion
  97         noise_cave1             = new Noise(&params->np_cave1,             seed, csize.X, csize.Y + 1, csize.Z);
  98         noise_cave2             = new Noise(&params->np_cave2,             seed, csize.X, csize.Y + 1, csize.Z);
  99         noise_massive_caves     = new Noise(&params->np_massive_caves,     seed, csize.X, csize.Y + 1, csize.Z);
 100
 101         this->humid_rivers       = (spflags & MGVALLEYS_HUMID_RIVERS);
 102         this->use_altitude_chill = (spflags & MGVALLEYS_ALT_CHILL);
 103         this->humidity_adjust    = bp->np_humidity.offset - 50.f;
 104
 105         // a small chance of overflows if the settings are very high
 106         this->cave_water_max_height = water_level + MYMAX(0, water_features_lim - 4) * 50;
 107         this->lava_max_height       = water_level + MYMAX(0, lava_features_lim - 4) * 50;
 108
 109         tcave_cache = new float[csize.Y + 2];
 110
 111         // Resolve content to be used
 112         c_lava_source = ndef->getId("mapgen_lava_source");
 113 }
 114
 115
 116 MapgenValleys::~MapgenValleys()
 117 {
 118         delete noise_cave1;
 119         delete noise_cave2;
 120         delete noise_filler_depth;
 121         delete noise_inter_valley_fill;
 122         delete noise_inter_valley_slope;
 123         delete noise_rivers;
 124         delete noise_massive_caves;
 125         delete noise_terrain_height;
 126         delete noise_valley_depth;
 127         delete noise_valley_profile;
 128
 129         delete[] tcave_cache;
 130 }
 131
 132
 133 MapgenValleysParams::MapgenValleysParams()
 134 {
 135         spflags            = MGVALLEYS_HUMID_RIVERS | MGVALLEYS_ALT_CHILL;
 136         altitude_chill     = 90; // The altitude at which temperature drops by 20C.
 137         large_cave_depth   = -33;
 138         lava_features      = 0;  // How often water will occur in caves.
 139         massive_cave_depth = -256;  // highest altitude of massive caves
 140         river_depth        = 4;  // How deep to carve river channels.
 141         river_size         = 5;  // How wide to make rivers.
 142         water_features     = 0;  // How often water will occur in caves.
 143         cave_width         = 0.09;
 144
 145         np_cave1              = NoiseParams(0,     12,   v3f(61,   61,   61),   52534, 3, 0.5,   2.0);
 146         np_cave2              = NoiseParams(0,     12,   v3f(67,   67,   67),   10325, 3, 0.5,   2.0);
 147         np_filler_depth       = NoiseParams(0.f,   1.2f, v3f(256,  256,  256),  1605,  3, 0.5f,  2.f);
 148         np_inter_valley_fill  = NoiseParams(0.f,   1.f,  v3f(256,  512,  256),  1993,  6, 0.8f,  2.f);
 149         np_inter_valley_slope = NoiseParams(0.5f,  0.5f, v3f(128,  128,  128),  746,   1, 1.f,   2.f);
 150         np_rivers             = NoiseParams(0.f,   1.f,  v3f(256,  256,  256),  -6050, 5, 0.6f,  2.f);
 151         np_massive_caves      = NoiseParams(0.f,   1.f,  v3f(768,  256,  768),  59033, 6, 0.63f, 2.f);
 152         np_terrain_height     = NoiseParams(-10.f, 50.f, v3f(1024, 1024, 1024), 5202,  6, 0.4f,  2.f);
 153         np_valley_depth       = NoiseParams(5.f,   4.f,  v3f(512,  512,  512),  -1914, 1, 1.f,   2.f);
 154         np_valley_profile     = NoiseParams(0.6f,  0.5f, v3f(512,  512,  512),  777,   1, 1.f,   2.f);
 155 }
 156
 157
 158 void MapgenValleysParams::readParams(const Settings *settings)
 159 {
 160         settings->getFlagStrNoEx("mgvalleys_spflags",        spflags, flagdesc_mapgen_valleys);
 161         settings->getU16NoEx("mgvalleys_altitude_chill",     altitude_chill);
 162         settings->getS16NoEx("mgvalleys_large_cave_depth",   large_cave_depth);
 163         settings->getU16NoEx("mgvalleys_lava_features",      lava_features);
 164         settings->getS16NoEx("mgvalleys_massive_cave_depth", massive_cave_depth);
 165         settings->getU16NoEx("mgvalleys_river_depth",        river_depth);
 166         settings->getU16NoEx("mgvalleys_river_size",         river_size);
 167         settings->getU16NoEx("mgvalleys_water_features",     water_features);
 168         settings->getFloatNoEx("mgvalleys_cave_width",       cave_width);
 169
 170         settings->getNoiseParams("mgvalleys_np_cave1",              np_cave1);
 171         settings->getNoiseParams("mgvalleys_np_cave2",              np_cave2);
 172         settings->getNoiseParams("mgvalleys_np_filler_depth",       np_filler_depth);
 173         settings->getNoiseParams("mgvalleys_np_inter_valley_fill",  np_inter_valley_fill);
 174         settings->getNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
 175         settings->getNoiseParams("mgvalleys_np_rivers",             np_rivers);
 176         settings->getNoiseParams("mgvalleys_np_massive_caves",      np_massive_caves);
 177         settings->getNoiseParams("mgvalleys_np_terrain_height",     np_terrain_height);
 178         settings->getNoiseParams("mgvalleys_np_valley_depth",       np_valley_depth);
 179         settings->getNoiseParams("mgvalleys_np_valley_profile",     np_valley_profile);
 180 }
 181
 182
 183 void MapgenValleysParams::writeParams(Settings *settings) const
 184 {
 185         settings->setFlagStr("mgvalleys_spflags",        spflags, flagdesc_mapgen_valleys, U32_MAX);
 186         settings->setU16("mgvalleys_altitude_chill",     altitude_chill);
 187         settings->setS16("mgvalleys_large_cave_depth",   large_cave_depth);
 188         settings->setU16("mgvalleys_lava_features",      lava_features);
 189         settings->setS16("mgvalleys_massive_cave_depth", massive_cave_depth);
 190         settings->setU16("mgvalleys_river_depth",        river_depth);
 191         settings->setU16("mgvalleys_river_size",         river_size);
 192         settings->setU16("mgvalleys_water_features",     water_features);
 193         settings->setFloat("mgvalleys_cave_width",       cave_width);
 194
 195         settings->setNoiseParams("mgvalleys_np_cave1",              np_cave1);
 196         settings->setNoiseParams("mgvalleys_np_cave2",              np_cave2);
 197         settings->setNoiseParams("mgvalleys_np_filler_depth",       np_filler_depth);
 198         settings->setNoiseParams("mgvalleys_np_inter_valley_fill",  np_inter_valley_fill);
 199         settings->setNoiseParams("mgvalleys_np_inter_valley_slope", np_inter_valley_slope);
 200         settings->setNoiseParams("mgvalleys_np_rivers",             np_rivers);
 201         settings->setNoiseParams("mgvalleys_np_massive_caves",      np_massive_caves);
 202         settings->setNoiseParams("mgvalleys_np_terrain_height",     np_terrain_height);
 203         settings->setNoiseParams("mgvalleys_np_valley_depth",       np_valley_depth);
 204         settings->setNoiseParams("mgvalleys_np_valley_profile",     np_valley_profile);
 205 }
 206
 207
 208 ///////////////////////////////////////
 209
 210
 211 void MapgenValleys::makeChunk(BlockMakeData *data)
 212 {
 213         // Pre-conditions
 214         assert(data->vmanip);
 215         assert(data->nodedef);
 216         assert(data->blockpos_requested.X >= data->blockpos_min.X &&
 217                 data->blockpos_requested.Y >= data->blockpos_min.Y &&
 218                 data->blockpos_requested.Z >= data->blockpos_min.Z);
 219         assert(data->blockpos_requested.X <= data->blockpos_max.X &&
 220                 data->blockpos_requested.Y <= data->blockpos_max.Y &&
 221                 data->blockpos_requested.Z <= data->blockpos_max.Z);
 222
 223         this->generating = true;
 224         this->vm = data->vmanip;
 225         this->ndef = data->nodedef;
 226
 227         //TimeTaker t("makeChunk");
 228
 229         v3s16 blockpos_min = data->blockpos_min;
 230         v3s16 blockpos_max = data->blockpos_max;
 231         node_min = blockpos_min * MAP_BLOCKSIZE;
 232         node_max = (blockpos_max + v3s16(1, 1, 1)) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
 233         full_node_min = (blockpos_min - 1) * MAP_BLOCKSIZE;
 234         full_node_max = (blockpos_max + 2) * MAP_BLOCKSIZE - v3s16(1, 1, 1);
 235
 236         blockseed = getBlockSeed2(full_node_min, seed);
 237
 238         // Generate biome noises.  Note this must be executed strictly before
 239         // generateTerrain, because generateTerrain depends on intermediate
 240         // biome-related noises.
 241         m_bgen->calcBiomeNoise(node_min);
 242
 243         // Generate noise maps and base terrain height.
 244         // Modify heat and humidity maps.
 245         calculateNoise();
 246
 247         // Generate base terrain with initial heightmaps
 248         s16 stone_surface_max_y = generateTerrain();
 249
 250         // Recalculate heightmap
 251         updateHeightmap(node_min, node_max);
 252
 253         // Place biome-specific nodes and build biomemap
 254         MgStoneType stone_type = generateBiomes();
 255
 256         // Cave creation.
 257         if (flags & MG_CAVES)
 258                 generateCaves(stone_surface_max_y, large_cave_depth);
 259
 260         // Dungeon creation
 261         if ((flags & MG_DUNGEONS) && node_max.Y < 50)
 262                 generateDungeons(stone_surface_max_y, stone_type);
 263
 264         // Generate the registered decorations
 265         if (flags & MG_DECORATIONS)
 266                 m_emerge->decomgr->placeAllDecos(this, blockseed, node_min, node_max);
 267
 268         // Generate the registered ores
 269         m_emerge->oremgr->placeAllOres(this, blockseed, node_min, node_max);
 270
 271         // Sprinkle some dust on top after everything else was generated
 272         dustTopNodes();
 273
 274         //TimeTaker tll("liquid_lighting");
 275
 276         updateLiquid(&data->transforming_liquid, full_node_min, full_node_max);
 277
 278         if (flags & MG_LIGHT)
 279                 calcLighting(
 280                                 node_min - v3s16(0, 1, 0),
 281                                 node_max + v3s16(0, 1, 0),
 282                                 full_node_min,
 283                                 full_node_max);
 284
 285         //mapgen_profiler->avg("liquid_lighting", tll.stop() / 1000.f);
 286         //mapgen_profiler->avg("makeChunk", t.stop() / 1000.f);
 287
 288         this->generating = false;
 289 }
 290
 291
 292 // Populate the noise tables and do most of the
 293 // calculation necessary to determine terrain height.
 294 void MapgenValleys::calculateNoise()
 295 {
 296         //TimeTaker t("calculateNoise", NULL, PRECISION_MICRO);
 297
 298         int x = node_min.X;
 299         int y = node_min.Y - 1;
 300         int z = node_min.Z;
 301
 302         //TimeTaker tcn("actualNoise");
 303
 304         noise_inter_valley_slope->perlinMap2D(x, z);
 305         noise_rivers->perlinMap2D(x, z);
 306         noise_terrain_height->perlinMap2D(x, z);
 307         noise_valley_depth->perlinMap2D(x, z);
 308         noise_valley_profile->perlinMap2D(x, z);
 309
 310         noise_inter_valley_fill->perlinMap3D(x, y, z);
 311
 312         //mapgen_profiler->avg("noisemaps", tcn.stop() / 1000.f);
 313
 314         float heat_offset = 0.f;
 315         float humidity_scale = 1.f;
 316
 317         // Altitude chill tends to reduce the average heat.
 318         if (use_altitude_chill)
 319                 heat_offset = 5.f;
 320
 321         // River humidity tends to increase the humidity range.
 322         if (humid_rivers) {
 323                 humidity_scale = 0.8f;
 324         }
 325
 326         for (s32 index = 0; index < csize.X * csize.Z; index++) {
 327                 m_bgen->heatmap[index] += heat_offset;
 328                 m_bgen->humidmap[index] *= humidity_scale;
 329         }
 330
 331         TerrainNoise tn;
 332
 333         u32 index = 0;
 334         for (tn.z = node_min.Z; tn.z <= node_max.Z; tn.z++)
 335         for (tn.x = node_min.X; tn.x <= node_max.X; tn.x++, index++) {
 336                 // The parameters that we actually need to generate terrain
 337                 //  are passed by address (and the return value).
 338                 tn.terrain_height    = noise_terrain_height->result[index];
 339                 // River noise is replaced with base terrain, which
 340                 // is basically the height of the water table.
 341                 tn.rivers            = &noise_rivers->result[index];
 342                 // Valley depth noise is replaced with the valley
 343                 // number that represents the height of terrain
 344                 // over rivers and is used to determine about
 345                 // how close a river is for humidity calculation.
 346                 tn.valley            = &noise_valley_depth->result[index];
 347                 tn.valley_profile    = noise_valley_profile->result[index];
 348                 // Slope noise is replaced by the calculated slope
 349                 // which is used to get terrain height in the slow
 350                 // method, to create sharper mountains.
 351                 tn.slope             = &noise_inter_valley_slope->result[index];
 352                 tn.inter_valley_fill = noise_inter_valley_fill->result[index];
 353
 354                 // This is the actual terrain height.
 355                 float mount = terrainLevelFromNoise(&tn);
 356                 noise_terrain_height->result[index] = mount;
 357         }
 358 }
 359
 360
 361 // This keeps us from having to maintain two similar sets of
 362 //  complicated code to determine ground level.
 363 float MapgenValleys::terrainLevelFromNoise(TerrainNoise *tn)
 364 {
 365         // The square function changes the behaviour of this noise:
 366         //  very often small, and sometimes very high.
 367         float valley_d = MYSQUARE(*tn->valley);
 368
 369         // valley_d is here because terrain is generally higher where valleys
 370         //  are deep (mountains). base represents the height of the
 371         //  rivers, most of the surface is above.
 372         float base = tn->terrain_height + valley_d;
 373
 374         // "river" represents the distance from the river, in arbitrary units.
 375         float river = fabs(*tn->rivers) - river_size_factor;
 376
 377         // Use the curve of the function 1-exp(-(x/a)^2) to model valleys.
 378         //  Making "a" vary (0 < a <= 1) changes the shape of the valleys.
 379         //  Try it with a geometry software !
 380         //   (here x = "river" and a = valley_profile).
 381         //  "valley" represents the height of the terrain, from the rivers.
 382         {
 383                 float t = river / tn->valley_profile;
 384                 *tn->valley = valley_d * (1.f - exp(- MYSQUARE(t)));
 385         }
 386
 387         // approximate height of the terrain at this point
 388         float mount = base + *tn->valley;
 389
 390         *tn->slope *= *tn->valley;
 391
 392         // Rivers are placed where "river" is negative, so where the original
 393         //  noise value is close to zero.
 394         // Base ground is returned as rivers since it's basically the water table.
 395         *tn->rivers = base;
 396         if (river < 0.f) {
 397                 // Use the the function -sqrt(1-x^2) which models a circle.
 398                 float depth;
 399                 {
 400                         float t = river / river_size_factor + 1;
 401                         depth = (river_depth_bed * sqrt(MYMAX(0, 1.f - MYSQUARE(t))));
 402                 }
 403
 404                 // base - depth : height of the bottom of the river
 405                 // water_level - 3 : don't make rivers below 3 nodes under the surface
 406                 // We use three because that's as low as the swamp biomes go.
 407                 // There is no logical equivalent to this using rangelim.
 408                 mount = MYMIN(MYMAX(base - depth, (float)(water_level - 3)), mount);
 409
 410                 // Slope has no influence on rivers.
 411                 *tn->slope = 0.f;
 412         }
 413
 414         return mount;
 415 }
 416
 417
 418 // This avoids duplicating the code in terrainLevelFromNoise, adding
 419 // only the final step of terrain generation without a noise map.
 420 float MapgenValleys::adjustedTerrainLevelFromNoise(TerrainNoise *tn)
 421 {
 422         float mount = terrainLevelFromNoise(tn);
 423         s16 y_start = myround(mount);
 424
 425         for (s16 y = y_start; y <= y_start + 1000; y++) {
 426                 float fill = NoisePerlin3D(&noise_inter_valley_fill->np, tn->x, y, tn->z, seed);
 427
 428                 if (fill * *tn->slope < y - mount) {
 429                         mount = MYMAX(y - 1, mount);
 430                         break;
 431                 }
 432         }
 433
 434         return mount;
 435 }
 436
 437
 438 int MapgenValleys::getSpawnLevelAtPoint(v2s16 p)
 439 {
 440         // Check to make sure this isn't a request for a location in a river.
 441         float rivers = NoisePerlin2D(&noise_rivers->np, p.X, p.Y, seed);
 442         if (fabs(rivers) < river_size_factor)
 443                 return MAX_MAP_GENERATION_LIMIT;  // Unsuitable spawn point
 444
 445         s16 level_at_point = terrainLevelAtPoint(p.X, p.Y);
 446         if (level_at_point <= water_level ||
 447                         level_at_point > water_level + 32)
 448                 return MAX_MAP_GENERATION_LIMIT;  // Unsuitable spawn point
 449         else
 450                 return level_at_point;
 451 }
 452
 453
 454 float MapgenValleys::terrainLevelAtPoint(s16 x, s16 z)
 455 {
 456         TerrainNoise tn;
 457
 458         float rivers = NoisePerlin2D(&noise_rivers->np, x, z, seed);
 459         float valley = NoisePerlin2D(&noise_valley_depth->np, x, z, seed);
 460         float inter_valley_slope = NoisePerlin2D(&noise_inter_valley_slope->np, x, z, seed);
 461
 462         tn.x                 = x;
 463         tn.z                 = z;
 464         tn.terrain_height    = NoisePerlin2D(&noise_terrain_height->np, x, z, seed);
 465         tn.rivers            = &rivers;
 466         tn.valley            = &valley;
 467         tn.valley_profile    = NoisePerlin2D(&noise_valley_profile->np, x, z, seed);
 468         tn.slope             = &inter_valley_slope;
 469         tn.inter_valley_fill = 0.f;
 470
 471         return adjustedTerrainLevelFromNoise(&tn);
 472 }
 473
 474
 475 int MapgenValleys::generateTerrain()
 476 {
 477         // Raising this reduces the rate of evaporation.
 478         static const float evaporation = 300.f;
 479         // from the lua
 480         static const float humidity_dropoff = 4.f;
 481         // constant to convert altitude chill (compatible with lua) to heat
 482         static const float alt_to_heat = 20.f;
 483         // humidity reduction by altitude
 484         static const float alt_to_humid = 10.f;
 485
 486         MapNode n_air(CONTENT_AIR);
 487         MapNode n_river_water(c_river_water_source);
 488         MapNode n_stone(c_stone);
 489         MapNode n_water(c_water_source);
 490
 491         v3s16 em = vm->m_area.getExtent();
 492         s16 surface_max_y = -MAX_MAP_GENERATION_LIMIT;
 493         u32 index_2d = 0;
 494
 495         for (s16 z = node_min.Z; z <= node_max.Z; z++)
 496         for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
 497                 float river_y = noise_rivers->result[index_2d];
 498                 float surface_y = noise_terrain_height->result[index_2d];
 499                 float slope = noise_inter_valley_slope->result[index_2d];
 500                 float t_heat = m_bgen->heatmap[index_2d];
 501
 502                 heightmap[index_2d] = -MAX_MAP_GENERATION_LIMIT;
 503
 504                 if (surface_y > surface_max_y)
 505                         surface_max_y = ceil(surface_y);
 506
 507                 if (humid_rivers) {
 508                         // Derive heat from (base) altitude. This will be most correct
 509                         // at rivers, since other surface heights may vary below.
 510                         if (use_altitude_chill && (surface_y > 0.f || river_y > 0.f))
 511                                 t_heat -= alt_to_heat * MYMAX(surface_y, river_y) / altitude_chill;
 512
 513                         // If humidity is low or heat is high, lower the water table.
 514                         float delta = m_bgen->humidmap[index_2d] - 50.f;
 515                         if (delta < 0.f) {
 516                                 float t_evap = (t_heat - 32.f) / evaporation;
 517                                 river_y += delta * MYMAX(t_evap, 0.08f);
 518                         }
 519                 }
 520
 521                 u32 index_3d = (z - node_min.Z) * zstride_1u1d + (x - node_min.X);
 522                 u32 index_data = vm->m_area.index(x, node_min.Y - 1, z);
 523
 524                 // Mapgens concern themselves with stone and water.
 525                 for (s16 y = node_min.Y - 1; y <= node_max.Y + 1; y++) {
 526                         if (vm->m_data[index_data].getContent() == CONTENT_IGNORE) {
 527                                 float fill = noise_inter_valley_fill->result[index_3d];
 528                                 float surface_delta = (float)y - surface_y;
 529                                 bool river = y + 1 < river_y;
 530
 531                                 if (slope * fill > surface_delta) {
 532                                         // ground
 533                                         vm->m_data[index_data] = n_stone;
 534                                         if (y > heightmap[index_2d])
 535                                                 heightmap[index_2d] = y;
 536                                         if (y > surface_max_y)
 537                                                 surface_max_y = y;
 538                                 } else if (y <= water_level) {
 539                                         // sea
 540                                         vm->m_data[index_data] = n_water;
 541                                 } else if (river) {
 542                                         // river
 543                                         vm->m_data[index_data] = n_river_water;
 544                                 } else {  // air
 545                                         vm->m_data[index_data] = n_air;
 546                                 }
 547                         }
 548
 549                         vm->m_area.add_y(em, index_data, 1);
 550                         index_3d += ystride;
 551                 }
 552
 553                 if (heightmap[index_2d] == -MAX_MAP_GENERATION_LIMIT) {
 554                         s16 surface_y_int = myround(surface_y);
 555                         if (surface_y_int > node_max.Y + 1 || surface_y_int < node_min.Y - 1) {
 556                                 // If surface_y is outside the chunk, it's good enough.
 557                                 heightmap[index_2d] = surface_y_int;
 558                         } else {
 559                                 // If the ground is outside of this chunk, but surface_y
 560                                 // is within the chunk, give a value outside.
 561                                 heightmap[index_2d] = node_min.Y - 2;
 562                         }
 563                 }
 564
 565                 if (humid_rivers) {
 566                         // Use base ground (water table) in a riverbed, to
 567                         // avoid an unnatural rise in humidity.
 568                         float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
 569                         float humid = m_bgen->humidmap[index_2d];
 570                         float water_depth = (t_alt - river_y) / humidity_dropoff;
 571                         humid *= 1.f + pow(0.5f, MYMAX(water_depth, 1.f));
 572
 573                         // Reduce humidity with altitude (ignoring riverbeds).
 574                         // This is similar to the lua version's seawater adjustment,
 575                         // but doesn't increase the base humidity, which causes
 576                         // problems with the default biomes.
 577                         if (t_alt > 0.f)
 578                                 humid -= alt_to_humid * t_alt / altitude_chill;
 579
 580                         m_bgen->humidmap[index_2d] = humid;
 581                 }
 582
 583                 // Assign the heat adjusted by any changed altitudes.
 584                 // The altitude will change about half the time.
 585                 if (use_altitude_chill) {
 586                         // ground height ignoring riverbeds
 587                         float t_alt = MYMAX(noise_rivers->result[index_2d], (float)heightmap[index_2d]);
 588                         if (humid_rivers && heightmap[index_2d] == (s16)myround(surface_y))
 589                                 // The altitude hasn't changed. Use the first result.
 590                                 m_bgen->heatmap[index_2d] = t_heat;
 591                         else if (t_alt > 0.f)
 592                                 m_bgen->heatmap[index_2d] -= alt_to_heat * t_alt / altitude_chill;
 593                 }
 594         }
 595
 596         return surface_max_y;
 597 }
 598
 599 void MapgenValleys::generateCaves(s16 max_stone_y, s16 large_cave_depth)
 600 {
 601         if (max_stone_y < node_min.Y)
 602                 return;
 603
 604         noise_cave1->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
 605         noise_cave2->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
 606
 607         PseudoRandom ps(blockseed + 72202);
 608
 609         MapNode n_air(CONTENT_AIR);
 610         MapNode n_lava(c_lava_source);
 611         MapNode n_water(c_river_water_source);
 612
 613         v3s16 em = vm->m_area.getExtent();
 614
 615         // Cave blend distance near YMIN, YMAX
 616         const float massive_cave_blend = 128.f;
 617         // noise threshold for massive caves
 618         const float massive_cave_threshold = 0.6f;
 619         // mct: 1 = small rare caves, 0.5 1/3rd ground volume, 0 = 1/2 ground volume.
 620
 621         float yblmin = -mapgen_limit + massive_cave_blend * 1.5f;
 622         float yblmax = massive_cave_depth - massive_cave_blend * 1.5f;
 623         bool made_a_big_one = false;
 624
 625         // Cache the tcave values as they only vary by altitude.
 626         if (node_max.Y <= massive_cave_depth) {
 627                 noise_massive_caves->perlinMap3D(node_min.X, node_min.Y - 1, node_min.Z);
 628
 629                 for (s16 y = node_min.Y - 1; y <= node_max.Y; y++) {
 630                         float tcave = massive_cave_threshold;
 631
 632                         if (y < yblmin) {
 633                                 float t = (yblmin - y) / massive_cave_blend;
 634                                 tcave += MYSQUARE(t);
 635                         } else if (y > yblmax) {
 636                                 float t = (y - yblmax) / massive_cave_blend;
 637                                 tcave += MYSQUARE(t);
 638                         }
 639
 640                         tcave_cache[y - node_min.Y + 1] = tcave;
 641                 }
 642         }
 643
 644         // lava_depth varies between one and ten as you approach
 645         //  the bottom of the world.
 646         s16 lava_depth = ceil((lava_max_height - node_min.Y + 1) * 10.f / mapgen_limit);
 647         // This allows random lava spawns to be less common at the surface.
 648         s16 lava_chance = MYCUBE(lava_features_lim) * lava_depth;
 649         // water_depth varies between ten and one on the way down.
 650         s16 water_depth = ceil((mapgen_limit - abs(node_min.Y) + 1) * 10.f / mapgen_limit);
 651         // This allows random water spawns to be more common at the surface.
 652         s16 water_chance = MYCUBE(water_features_lim) * water_depth;
 653
 654         // Reduce the odds of overflows even further.
 655         if (node_max.Y > water_level) {
 656                 lava_chance /= 3;
 657                 water_chance /= 3;
 658         }
 659
 660         u32 index_2d = 0;
 661         for (s16 z = node_min.Z; z <= node_max.Z; z++)
 662         for (s16 x = node_min.X; x <= node_max.X; x++, index_2d++) {
 663                 Biome *biome = (Biome *)m_bmgr->getRaw(biomemap[index_2d]);
 664                 bool tunnel_air_above = false;
 665                 bool is_under_river = false;
 666                 bool underground = false;
 667                 u32 index_data = vm->m_area.index(x, node_max.Y, z);
 668                 u32 index_3d = (z - node_min.Z) * zstride_1d + csize.Y * ystride + (x - node_min.X);
 669
 670                 // Dig caves on down loop to check for air above.
 671                 // Don't excavate the overgenerated stone at node_max.Y + 1,
 672                 // this creates a 'roof' over the tunnel, preventing light in
 673                 // tunnels at mapchunk borders when generating mapchunks upwards.
 674                 // This 'roof' is removed when the mapchunk above is generated.
 675                 for (s16 y = node_max.Y; y >= node_min.Y - 1; y--,
 676                                 index_3d -= ystride,
 677                                 vm->m_area.add_y(em, index_data, -1)) {
 678
 679                         float terrain = noise_terrain_height->result[index_2d];
 680
 681                         // Saves some time.
 682                         if (y > terrain + 10)
 683                                 continue;
 684                         else if (y < terrain - 40)
 685                                 underground = true;
 686
 687                         // Dig massive caves.
 688                         if (node_max.Y <= massive_cave_depth
 689                                         && noise_massive_caves->result[index_3d]
 690                                         > tcave_cache[y - node_min.Y + 1]) {
 691                                 vm->m_data[index_data] = n_air;
 692                                 made_a_big_one = true;
 693                                 continue;
 694                         }
 695
 696                         content_t c = vm->m_data[index_data].getContent();
 697                         // Detect river water to place riverbed nodes in tunnels
 698                         if (c == biome->c_river_water)
 699                                 is_under_river = true;
 700
 701                         float d1 = contour(noise_cave1->result[index_3d]);
 702                         float d2 = contour(noise_cave2->result[index_3d]);
 703
 704                         if (d1 * d2 > cave_width && ndef->get(c).is_ground_content) {
 705                                 // in a tunnel
 706                                 vm->m_data[index_data] = n_air;
 707                                 tunnel_air_above = true;
 708                         } else if (c == biome->c_filler || c == biome->c_stone) {
 709                                 if (tunnel_air_above) {
 710                                         // at the tunnel floor
 711                                         s16 sr = ps.range(0, 39);
 712                                         u32 j = index_data;
 713                                         vm->m_area.add_y(em, j, 1);
 714
 715                                         if (sr > terrain - y) {
 716                                                 // Put biome nodes in tunnels near the surface
 717                                                 if (is_under_river)
 718                                                         vm->m_data[index_data] = MapNode(biome->c_riverbed);
 719                                                 else if (underground)
 720                                                         vm->m_data[index_data] = MapNode(biome->c_filler);
 721                                                 else
 722                                                         vm->m_data[index_data] = MapNode(biome->c_top);
 723                                         } else if (sr < 3 && underground) {
 724                                                 sr = abs(ps.next());
 725                                                 if (lava_features_lim > 0 && y <= lava_max_height
 726                                                                 && c == biome->c_stone && sr < lava_chance)
 727                                                         vm->m_data[j] = n_lava;
 728
 729                                                 sr -= lava_chance;
 730
 731                                                 // If sr < 0 then we should have already placed lava --
 732                                                 // don't immediately dump water on it.
 733                                                 if (water_features_lim > 0 && y <= cave_water_max_height
 734                                                                 && sr >= 0 && sr < water_chance)
 735                                                         vm->m_data[j] = n_water;
 736                                         }
 737                                 }
 738
 739                                 tunnel_air_above = false;
 740                                 underground = true;
 741                         } else {
 742                                 tunnel_air_above = false;
 743                         }
 744                 }
 745         }
 746
 747         if (node_max.Y <= large_cave_depth && !made_a_big_one) {
 748                 u32 bruises_count = ps.range(0, 2);
 749                 for (u32 i = 0; i < bruises_count; i++) {
 750                         CavesRandomWalk cave(ndef, &gennotify, seed, water_level,
 751                                 c_water_source, c_lava_source);
 752
 753                         cave.makeCave(vm, node_min, node_max, &ps, true, max_stone_y, heightmap);
 754                 }
 755         }
 756 }